@elabs-ai/components-editor 4.0.0

package/dist/chunk-LBC5VJBD.js

@@ -0,0 +1,3748 @@
+"use client";
+
+// src/editor-context-menu/editor-context-menu.tsx
+import {
+  ContextMenu,
+  ContextMenuContent,
+  ContextMenuItem,
+  ContextMenuSeparator,
+  ContextMenuShortcut,
+  ContextMenuTrigger
+} from "@elabs-ai/components-ui";
+import "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+function EditorContextMenu({ editor: editor2, readOnly = false, children }) {
+  const selection = () => {
+    if (!editor2) return null;
+    const model = editor2.getModel();
+    const sel = editor2.getSelection();
+    return model && sel ? { editor: editor2, model, sel } : null;
+  };
+  const copy = async () => {
+    const ctx2 = selection();
+    if (!ctx2) return;
+    const text = ctx2.model.getValueInRange(ctx2.sel);
+    if (text && typeof navigator !== "undefined" && navigator.clipboard) {
+      await navigator.clipboard.writeText(text);
+    }
+    ctx2.editor.focus();
+  };
+  const cut = async () => {
+    const ctx2 = selection();
+    if (!ctx2) return;
+    const text = ctx2.model.getValueInRange(ctx2.sel);
+    if (text && typeof navigator !== "undefined" && navigator.clipboard) {
+      await navigator.clipboard.writeText(text);
+      ctx2.editor.executeEdits("brand-cut", [{ range: ctx2.sel, text: "", forceMoveMarkers: true }]);
+    }
+    ctx2.editor.focus();
+  };
+  const paste = async () => {
+    const ctx2 = selection();
+    if (!ctx2 || typeof navigator === "undefined" || !navigator.clipboard) return;
+    const text = await navigator.clipboard.readText();
+    ctx2.editor.executeEdits("brand-paste", [{ range: ctx2.sel, text, forceMoveMarkers: true }]);
+    ctx2.editor.focus();
+  };
+  const selectAll = () => {
+    const ctx2 = selection();
+    if (!ctx2) return;
+    ctx2.editor.setSelection(ctx2.model.getFullModelRange());
+    ctx2.editor.focus();
+  };
+  const runAction = (id) => {
+    editor2?.focus();
+    void editor2?.getAction(id)?.run();
+  };
+  return /* @__PURE__ */ jsxs(ContextMenu, { children: [
+    /* @__PURE__ */ jsx(ContextMenuTrigger, { asChild: true, children }),
+    /* @__PURE__ */ jsxs(ContextMenuContent, { className: "w-52", children: [
+      !readOnly ? /* @__PURE__ */ jsxs(ContextMenuItem, { onSelect: () => void cut(), children: [
+        "Cut",
+        /* @__PURE__ */ jsx(ContextMenuShortcut, { children: "\u2318X" })
+      ] }) : null,
+      /* @__PURE__ */ jsxs(ContextMenuItem, { onSelect: () => void copy(), children: [
+        "Copy",
+        /* @__PURE__ */ jsx(ContextMenuShortcut, { children: "\u2318C" })
+      ] }),
+      !readOnly ? /* @__PURE__ */ jsxs(ContextMenuItem, { onSelect: () => void paste(), children: [
+        "Paste",
+        /* @__PURE__ */ jsx(ContextMenuShortcut, { children: "\u2318V" })
+      ] }) : null,
+      /* @__PURE__ */ jsx(ContextMenuSeparator, {}),
+      /* @__PURE__ */ jsxs(ContextMenuItem, { onSelect: selectAll, children: [
+        "Select all",
+        /* @__PURE__ */ jsx(ContextMenuShortcut, { children: "\u2318A" })
+      ] }),
+      !readOnly ? /* @__PURE__ */ jsxs(ContextMenuItem, { onSelect: () => runAction("editor.action.formatDocument"), children: [
+        "Format document",
+        /* @__PURE__ */ jsx(ContextMenuShortcut, { children: "\u21E7\u2325F" })
+      ] }) : null,
+      /* @__PURE__ */ jsx(ContextMenuSeparator, {}),
+      /* @__PURE__ */ jsxs(ContextMenuItem, { onSelect: () => runAction("editor.action.quickCommand"), children: [
+        "Command palette",
+        /* @__PURE__ */ jsx(ContextMenuShortcut, { children: "F1" })
+      ] })
+    ] })
+  ] });
+}
+
+// src/lib/monaco-theme-bridge.ts
+import { oklchToHex, resolveThemeIsDark } from "@elabs-ai/components-tokens";
+var hexCache = /* @__PURE__ */ new Map();
+var ctx = null;
+function resolveCssColor(value, fallback = "#000000") {
+  const raw = value.trim();
+  if (!raw) return fallback;
+  if (/^#([0-9a-f]{3,8})$/i.test(raw)) return raw;
+  const cached = hexCache.get(raw);
+  if (cached) return cached;
+  const viaOklch = oklchToHex(raw);
+  if (viaOklch) {
+    hexCache.set(raw, viaOklch);
+    return viaOklch;
+  }
+  if (typeof document === "undefined") return fallback;
+  if (!ctx) {
+    const canvas = document.createElement("canvas");
+    canvas.width = 1;
+    canvas.height = 1;
+    ctx = canvas.getContext("2d", { willReadFrequently: true });
+  }
+  if (!ctx) return fallback;
+  ctx.fillStyle = "#000000";
+  ctx.fillStyle = fallback;
+  ctx.fillStyle = raw;
+  ctx.clearRect(0, 0, 1, 1);
+  ctx.fillRect(0, 0, 1, 1);
+  const data = ctx.getImageData(0, 0, 1, 1).data;
+  const r = data[0] ?? 0;
+  const g = data[1] ?? 0;
+  const b = data[2] ?? 0;
+  const a = data[3] ?? 255;
+  const hex = a < 255 ? `#${byte(r)}${byte(g)}${byte(b)}${byte(a)}` : `#${byte(r)}${byte(g)}${byte(b)}`;
+  hexCache.set(raw, hex);
+  return hex;
+}
+var clamp01 = (n) => Number.isFinite(n) ? Math.min(1, Math.max(0, n)) : 1;
+var byte = (n) => n.toString(16).padStart(2, "0");
+function withAlpha(hex, alpha) {
+  const base = hex.slice(0, 7);
+  return `${base}${byte(Math.round(clamp01(alpha) * 255))}`;
+}
+function bare(hex) {
+  return hex.replace("#", "").slice(0, 6).padEnd(6, "0");
+}
+var channel = (hex, i) => parseInt(hex.slice(1 + i * 2, 3 + i * 2), 16) || 0;
+var toLinear = (c) => {
+  const s = c / 255;
+  return s <= 0.03928 ? s / 12.92 : Math.pow((s + 0.055) / 1.055, 2.4);
+};
+function luminance(hex) {
+  return 0.2126 * toLinear(channel(hex, 0)) + 0.7152 * toLinear(channel(hex, 1)) + 0.0722 * toLinear(channel(hex, 2));
+}
+function contrast(a, b) {
+  const la = luminance(a);
+  const lb = luminance(b);
+  return (Math.max(la, lb) + 0.05) / (Math.min(la, lb) + 0.05);
+}
+function mixHex(hex, target, t) {
+  const lerp = (i) => Math.round(channel(hex, i) + (channel(target, i) - channel(hex, i)) * t);
+  return `#${byte(lerp(0))}${byte(lerp(1))}${byte(lerp(2))}`;
+}
+function ensureReadable(hex, bg, minRatio) {
+  const base = hex.slice(0, 7);
+  if (contrast(base, bg) >= minRatio) return base;
+  const target = luminance(bg) > 0.5 ? "#000000" : "#ffffff";
+  let out = base;
+  for (let t = 0.1; t <= 1.0001; t += 0.1) {
+    out = mixHex(base, target, t);
+    if (contrast(out, bg) >= minRatio) break;
+  }
+  return out;
+}
+function builtinBase(rootEl) {
+  return resolveThemeIsDark(rootEl) ? "vs-dark" : "vs";
+}
+function buildBrandThemeData(rootEl) {
+  const el = rootEl ?? (typeof document !== "undefined" ? document.documentElement : null);
+  const read = (name, fallback) => resolveCssColor(el ? getComputedStyle(el).getPropertyValue(name) : "", fallback);
+  const background = read("--background", "#ffffff");
+  const foreground = read("--foreground", "#000000");
+  const muted = read("--muted", background);
+  const mutedFg = read("--muted-foreground", foreground);
+  const border = read("--border", muted);
+  const primary = read("--primary", foreground);
+  const ring = read("--ring", primary);
+  const popover = read("--popover", background);
+  const popoverFg = read("--popover-foreground", foreground);
+  const input = read("--input", border);
+  const chart1 = read("--chart-1", primary);
+  const chart2 = read("--chart-2", primary);
+  const chart3 = read("--chart-3", primary);
+  const chart4 = read("--chart-4", primary);
+  const success = read("--success", chart2);
+  const destructive = read("--destructive", "#ff0000");
+  const calcResult = ensureReadable(read("--calc-result", primary), background, 4.5);
+  const colors = {
+    "editor.background": background,
+    "editor.foreground": foreground,
+    "editorGutter.background": background,
+    "editorLineNumber.foreground": withAlpha(mutedFg, 0.6),
+    "editorLineNumber.activeForeground": foreground,
+    "editorCursor.foreground": primary,
+    "editor.selectionBackground": withAlpha(primary, 0.28),
+    "editor.inactiveSelectionBackground": withAlpha(primary, 0.14),
+    "editor.selectionHighlightBackground": withAlpha(primary, 0.14),
+    "editor.lineHighlightBackground": withAlpha(foreground, 0.05),
+    "editor.lineHighlightBorder": "#00000000",
+    "editorIndentGuide.background1": withAlpha(border, 0.6),
+    "editorIndentGuide.activeBackground1": mutedFg,
+    "editorWhitespace.foreground": withAlpha(mutedFg, 0.35),
+    "editorBracketMatch.background": withAlpha(primary, 0.2),
+    "editorBracketMatch.border": withAlpha(primary, 0.45),
+    // Widgets — this is what makes Monaco's "built-in components" match brand-ui.
+    // A shadow lets the popover detach from the editor even on light themes where
+    // the popover surface and editor background are nearly identical.
+    "widget.shadow": "#0000002e",
+    "editorWidget.background": popover,
+    "editorWidget.foreground": popoverFg,
+    "editorWidget.border": border,
+    "editorHoverWidget.background": popover,
+    "editorHoverWidget.foreground": popoverFg,
+    "editorHoverWidget.border": border,
+    "editorSuggestWidget.background": popover,
+    "editorSuggestWidget.foreground": popoverFg,
+    "editorSuggestWidget.border": border,
+    "editorSuggestWidget.selectedBackground": withAlpha(primary, 0.18),
+    "editorSuggestWidget.selectedForeground": popoverFg,
+    "editorSuggestWidget.highlightForeground": primary,
+    "input.background": input,
+    "input.foreground": foreground,
+    "input.border": border,
+    focusBorder: ring,
+    "dropdown.background": popover,
+    "dropdown.foreground": popoverFg,
+    "dropdown.border": border,
+    "list.hoverBackground": withAlpha(mutedFg, 0.12),
+    "list.focusBackground": withAlpha(primary, 0.16),
+    // Context menu (Monaco's built-in, used when contextMenu="monaco").
+    "menu.background": popover,
+    "menu.foreground": popoverFg,
+    "menu.border": border,
+    "menu.selectionBackground": withAlpha(primary, 0.18),
+    "menu.selectionForeground": popoverFg,
+    "menu.separatorBackground": withAlpha(border, 0.8),
+    "scrollbarSlider.background": withAlpha(mutedFg, 0.2),
+    "scrollbarSlider.hoverBackground": withAlpha(mutedFg, 0.35),
+    "scrollbarSlider.activeBackground": withAlpha(mutedFg, 0.5),
+    // Minimap (off by default; themed for when it's enabled via `options`).
+    "minimap.background": background,
+    "minimapSlider.background": withAlpha(mutedFg, 0.18),
+    "minimapSlider.hoverBackground": withAlpha(mutedFg, 0.3),
+    "minimapSlider.activeBackground": withAlpha(mutedFg, 0.45),
+    "editorError.foreground": destructive,
+    "editorWarning.foreground": read("--warning", chart4),
+    // Inlay hints (#220 calc result inlays) — calm, legible, themed from the calc
+    // result token; transparent plate so it reads as an annotation, not a chip.
+    "editorInlayHint.foreground": calcResult,
+    "editorInlayHint.background": "#00000000",
+    "editorInlayHint.typeForeground": calcResult,
+    "editorInlayHint.parameterForeground": calcResult,
+    // Diff editor — brand the add/remove bands from success/destructive tokens
+    // (instead of Monaco's default green/red) at low alpha so syntax reads on top.
+    "diffEditor.insertedTextBackground": withAlpha(success, 0.16),
+    "diffEditor.removedTextBackground": withAlpha(destructive, 0.16),
+    "diffEditor.insertedLineBackground": withAlpha(success, 0.08),
+    "diffEditor.removedLineBackground": withAlpha(destructive, 0.08),
+    "diffEditorGutter.insertedLineBackground": withAlpha(success, 0.12),
+    "diffEditorGutter.removedLineBackground": withAlpha(destructive, 0.12),
+    "diffEditorOverview.insertedForeground": withAlpha(success, 0.6),
+    "diffEditorOverview.removedForeground": withAlpha(destructive, 0.6),
+    "diffEditor.border": border
+  };
+  const ink = (hex, ratio = 4.5) => bare(ensureReadable(hex, background, ratio));
+  const rules = [
+    { token: "", foreground: bare(foreground), background: bare(background) },
+    { token: "comment", foreground: ink(mutedFg, 3.2), fontStyle: "italic" },
+    { token: "keyword", foreground: ink(primary) },
+    { token: "operator", foreground: ink(primary) },
+    { token: "string", foreground: ink(chart2) },
+    { token: "number", foreground: ink(chart4) },
+    { token: "regexp", foreground: ink(chart4) },
+    { token: "constant", foreground: ink(chart4) },
+    { token: "type", foreground: ink(chart1) },
+    { token: "type.identifier", foreground: ink(chart1) },
+    { token: "function", foreground: ink(chart3) },
+    { token: "identifier", foreground: bare(foreground) },
+    { token: "variable", foreground: bare(foreground) },
+    { token: "variable.predefined", foreground: ink(chart3) },
+    { token: "delimiter", foreground: ink(mutedFg, 3.2) },
+    { token: "tag", foreground: ink(primary) },
+    { token: "attribute.name", foreground: ink(chart3) },
+    { token: "attribute.value", foreground: ink(chart2) },
+    { token: "key", foreground: ink(chart1) },
+    // JSON keys
+    { token: "string.key", foreground: ink(chart1) },
+    { token: "string.value", foreground: ink(chart2) },
+    { token: "invalid", foreground: ink(destructive) },
+    { token: "namespace", foreground: ink(success) }
+  ];
+  return { base: "vs", inherit: true, colors, rules };
+}
+function brandThemeId(theme) {
+  return `brand-${theme}`;
+}
+function applyBrandTheme(monaco2, theme, rootEl) {
+  const id = brandThemeId(theme);
+  const data = buildBrandThemeData(rootEl);
+  data.base = builtinBase(rootEl);
+  monaco2.editor.defineTheme(id, data);
+  monaco2.editor.setTheme(id);
+  return id;
+}
+
+// src/lib/use-data-theme.ts
+import { useEffect, useState } from "react";
+import { DEFAULT_THEME } from "@elabs-ai/components-tokens";
+function useDataTheme(target) {
+  const [state, setState] = useState({ theme: DEFAULT_THEME, revision: 0 });
+  useEffect(() => {
+    if (typeof document === "undefined") return;
+    const el = target ?? document.documentElement;
+    const read = () => {
+      const next = el.getAttribute("data-theme") ?? document.documentElement.getAttribute("data-theme");
+      setState((prev) => ({
+        // Any non-empty attribute value is a theme (ADR 0029 — names are open).
+        // Only "no attribute anywhere" keeps the previous value, which is what
+        // makes a late ThemeProvider write a no-op rather than a flash.
+        theme: next || prev.theme,
+        revision: prev.revision + 1
+      }));
+    };
+    read();
+    const observer = new MutationObserver(read);
+    observer.observe(el, { attributes: true, attributeFilter: ["data-theme"] });
+    if (el !== document.documentElement) {
+      observer.observe(document.documentElement, {
+        attributes: true,
+        attributeFilter: ["data-theme"]
+      });
+    }
+    return () => observer.disconnect();
+  }, [target]);
+  return state;
+}
+
+// src/code-editor/code-editor.tsx
+import * as monaco from "monaco-editor";
+import { cn } from "@elabs-ai/components-ui/lib/cn";
+import {
+  forwardRef,
+  useEffect as useEffect2,
+  useImperativeHandle,
+  useRef,
+  useState as useState2
+} from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var BASE_OPTIONS = {
+  automaticLayout: true,
+  minimap: { enabled: false },
+  scrollBeyondLastLine: false,
+  smoothScrolling: true,
+  fontLigatures: true,
+  fontSize: 13,
+  lineNumbersMinChars: 3,
+  padding: { top: 12, bottom: 12 },
+  scrollbar: { verticalScrollbarSize: 10, horizontalScrollbarSize: 10 }
+};
+var CodeEditor = forwardRef(function CodeEditor2({
+  value,
+  defaultValue,
+  onChange,
+  language = "typescript",
+  path,
+  readOnly = false,
+  height = "100%",
+  options,
+  ariaLabel,
+  ariaInvalid,
+  ariaDescribedBy,
+  contextMenu = "brand",
+  onMount,
+  actions,
+  className,
+  style,
+  ...props
+}, ref) {
+  const containerRef = useRef(null);
+  const [editor2, setEditor] = useState2(null);
+  const { theme, revision } = useDataTheme();
+  const onChangeRef = useRef(onChange);
+  onChangeRef.current = onChange;
+  const onMountRef = useRef(onMount);
+  onMountRef.current = onMount;
+  useImperativeHandle(ref, () => editor2, [
+    editor2
+  ]);
+  useEffect2(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    const model = monaco.editor.createModel(
+      value ?? defaultValue ?? "",
+      language,
+      path ? monaco.Uri.parse(`inmemory://brand/${path}`) : void 0
+    );
+    const instance = monaco.editor.create(container, {
+      ...BASE_OPTIONS,
+      readOnly,
+      // Disable Monaco's own menu unless explicitly opted into; "brand" renders
+      // brand-ui's ContextMenu around the editor instead.
+      contextmenu: contextMenu === "monaco",
+      // Monaco's accessible name comes from this construction option (it writes it
+      // onto its inner screen-reader <textarea>), not from a wrapper-div attribute.
+      ...ariaLabel !== void 0 ? { ariaLabel } : null,
+      model,
+      ...options
+    });
+    const sub = instance.onDidChangeModelContent(() => {
+      onChangeRef.current?.(instance.getValue());
+    });
+    setEditor(instance);
+    onMountRef.current?.(instance, monaco);
+    return () => {
+      sub.dispose();
+      instance.dispose();
+      model.dispose();
+      setEditor(null);
+    };
+  }, []);
+  useEffect2(() => {
+    if (!editor2 || value === void 0) return;
+    if (value !== editor2.getValue()) editor2.setValue(value);
+  }, [editor2, value]);
+  useEffect2(() => {
+    const model = editor2?.getModel();
+    if (model) monaco.editor.setModelLanguage(model, language);
+  }, [editor2, language]);
+  useEffect2(() => {
+    editor2?.updateOptions({ readOnly, contextmenu: contextMenu === "monaco" });
+  }, [editor2, readOnly, contextMenu]);
+  useEffect2(() => {
+    if (!editor2) return;
+    try {
+      applyBrandTheme(monaco, theme);
+    } catch (err) {
+      console.error("[@elabs-ai/components-editor] failed to apply brand theme", err);
+    }
+  }, [editor2, theme, revision]);
+  useEffect2(() => {
+    if (!editor2) return;
+    if (ariaLabel !== void 0) editor2.updateOptions({ ariaLabel });
+    const textarea = editor2.getDomNode()?.querySelector("textarea");
+    if (!textarea) return;
+    if (ariaLabel === void 0) textarea.removeAttribute("aria-label");
+    else textarea.setAttribute("aria-label", ariaLabel);
+    if (ariaInvalid === void 0) textarea.removeAttribute("aria-invalid");
+    else textarea.setAttribute("aria-invalid", String(ariaInvalid));
+    if (ariaDescribedBy === void 0) textarea.removeAttribute("aria-describedby");
+    else textarea.setAttribute("aria-describedby", ariaDescribedBy);
+  }, [editor2, ariaLabel, ariaInvalid, ariaDescribedBy]);
+  useEffect2(() => {
+    if (!editor2 || !actions || actions.length === 0) return;
+    const disposables = actions.map((a) => editor2.addAction(a));
+    return () => disposables.forEach((d) => d.dispose());
+  }, [editor2, actions]);
+  const resolvedStyle = {
+    height: typeof height === "number" ? `${height}px` : height,
+    ...style
+  };
+  const editorEl = /* @__PURE__ */ jsx2(
+    "div",
+    {
+      ref: containerRef,
+      "data-testid": "code-editor",
+      className: cn("h-full w-full overflow-hidden bg-background text-foreground", className),
+      style: resolvedStyle,
+      ...props
+    }
+  );
+  if (contextMenu === "brand") {
+    return /* @__PURE__ */ jsx2(EditorContextMenu, { editor: editor2, readOnly, children: editorEl });
+  }
+  return editorEl;
+});
+
+// src/calc-block/calc-editor.ts
+var CALC_FENCE_LANG = "calc";
+var OPEN_FENCE = /^(\s*)(`{3,}|~{3,})[ \t]*calc\b[ \t]*$/i;
+function findCalcFences(text) {
+  const lines = text.split("\n");
+  const fences = [];
+  let i = 0;
+  while (i < lines.length) {
+    const open = OPEN_FENCE.exec(lines[i] ?? "");
+    if (!open) {
+      i++;
+      continue;
+    }
+    const run = open[2] ?? "```";
+    const marker = run[0] ?? "`";
+    const closeRe = new RegExp(`^\\s*\\${marker}{${run.length},}\\s*$`);
+    let j = i + 1;
+    while (j < lines.length && !closeRe.test(lines[j] ?? "")) j++;
+    const openLine = i + 1;
+    const closeLine = j < lines.length ? j + 1 : lines.length + 1;
+    fences.push({
+      openLine,
+      closeLine,
+      bodyStartLine: openLine + 1,
+      bodyEndLine: closeLine - 1,
+      source: lines.slice(i + 1, j).join("\n")
+    });
+    i = j + 1;
+  }
+  return fences;
+}
+function calcLineLayout(source) {
+  const spans = [];
+  let offset = 0;
+  for (const text of source.split("\n")) {
+    spans.push({ text, offset });
+    offset += text.length + 1;
+  }
+  return spans;
+}
+function resolveResults(hooks, source, ctx2) {
+  const map = /* @__PURE__ */ new Map();
+  if (!hooks.evaluate) return map;
+  let sheet;
+  try {
+    sheet = hooks.evaluate(source, ctx2);
+  } catch {
+    return map;
+  }
+  for (const r of sheet.results ?? []) map.set(r.line, r);
+  return map;
+}
+function resolveHighlight(hooks, source, ctx2) {
+  const lines = source.split("\n");
+  if (hooks.tokenize) {
+    const { tokenize } = hooks;
+    return lines.map((line) => {
+      try {
+        return tokenize(line, ctx2) ?? [];
+      } catch {
+        return [];
+      }
+    });
+  }
+  if (hooks.evaluate) {
+    const byLine = resolveResults(hooks, source, ctx2);
+    return lines.map((_line, i) => byLine.get(i + 1)?.tokens ?? []);
+  }
+  return lines.map(() => []);
+}
+function inlayTextForResult(result) {
+  if (!result) return null;
+  if (result.error) return { text: `error: ${result.error.message}`, isError: true };
+  if (result.value) return { text: `= ${result.value.display}`, isError: false };
+  return null;
+}
+function resolveInlays(hooks, source, ctx2) {
+  const byLine = resolveResults(hooks, source, ctx2);
+  const out = [];
+  for (const [lineNumber, result] of byLine) {
+    const inlay = inlayTextForResult(result);
+    if (inlay) out.push({ lineNumber, text: inlay.text, isError: inlay.isError });
+  }
+  out.sort((a, b) => a.lineNumber - b.lineNumber);
+  return out;
+}
+function calcTokenClassName(kind, resolved) {
+  const base = `brand-calc-tok brand-calc-tok--${kind}`;
+  return resolved ? base : `${base} brand-calc-tok--unresolved`;
+}
+function identifierPrefix(line, column) {
+  const upto = line.slice(0, Math.max(0, column));
+  const m = /[A-Za-z_][A-Za-z0-9_]*$/.exec(upto);
+  return m ? m[0] : "";
+}
+var clamp = (n, lo, hi) => Math.min(hi, Math.max(lo, n));
+function calcDecorationSpecs(hooks, bodyStartLine, bodyLineTexts, ctx2) {
+  const tokensByLine = resolveHighlight(hooks, bodyLineTexts.join("\n"), ctx2);
+  const specs = [];
+  for (let i = 0; i < bodyLineTexts.length; i++) {
+    const lineText = bodyLineTexts[i] ?? "";
+    for (const t of tokensByLine[i] ?? []) {
+      const start = clamp(t.start, 0, lineText.length);
+      const end = clamp(t.end, start, lineText.length);
+      if (end <= start) continue;
+      specs.push({
+        lineNumber: bodyStartLine + i,
+        startColumn: start + 1,
+        endColumn: end + 1,
+        className: calcTokenClassName(t.kind, t.resolved)
+      });
+    }
+  }
+  return specs;
+}
+function calcInlaySpecs(hooks, bodyStartLine, bodyLineTexts, ctx2) {
+  return resolveInlays(hooks, bodyLineTexts.join("\n"), ctx2).map((inlay) => {
+    const i = inlay.lineNumber - 1;
+    const lineText = bodyLineTexts[i] ?? "";
+    return {
+      lineNumber: bodyStartLine + i,
+      column: lineText.length + 1,
+      text: inlay.text,
+      isError: inlay.isError
+    };
+  });
+}
+
+// src/calc-block/calc-editor-prose.ts
+import { Plugin, PluginKey } from "@milkdown/kit/prose/state";
+import { Decoration, DecorationSet } from "@milkdown/kit/prose/view";
+import { $prose } from "@milkdown/kit/utils";
+var clamp2 = (n, lo, hi) => Math.min(hi, Math.max(lo, n));
+var calcDecorationKey = new PluginKey("brand-calc-decorations");
+function inlayWidget(inlay) {
+  const span = document.createElement("span");
+  span.className = inlay.isError ? "brand-calc-inlay brand-calc-inlay--error" : "brand-calc-inlay";
+  span.textContent = inlay.text;
+  span.setAttribute("contenteditable", "false");
+  span.setAttribute("title", inlay.isError ? "Calc error" : "Calc result");
+  return span;
+}
+function buildCalcDecorations(doc, hooks) {
+  if (!hooks || !hooks.tokenize && !hooks.evaluate) return DecorationSet.empty;
+  const decorations = [];
+  doc.descendants((node, pos) => {
+    if (node.type.name !== "code_block" || node.attrs.language !== CALC_FENCE_LANG) {
+      return void 0;
+    }
+    const source = node.textContent;
+    const contentStart = pos + 1;
+    const layout = calcLineLayout(source);
+    const tokensByLine = resolveHighlight(hooks, source);
+    layout.forEach((span, i) => {
+      const lineStart = contentStart + span.offset;
+      for (const t of tokensByLine[i] ?? []) {
+        const start = clamp2(t.start, 0, span.text.length);
+        const end = clamp2(t.end, start, span.text.length);
+        if (end <= start) continue;
+        decorations.push(
+          Decoration.inline(lineStart + start, lineStart + end, {
+            class: calcTokenClassName(t.kind, t.resolved)
+          })
+        );
+      }
+    });
+    for (const inlay of resolveInlays(hooks, source)) {
+      const span = layout[inlay.lineNumber - 1];
+      if (!span) continue;
+      const at = contentStart + span.offset + span.text.length;
+      decorations.push(
+        Decoration.widget(at, () => inlayWidget(inlay), {
+          side: 1,
+          ignoreSelection: true,
+          key: `brand-calc-inlay:${String(inlay.lineNumber)}:${inlay.text}`
+        })
+      );
+    }
+    return false;
+  });
+  return DecorationSet.create(doc, decorations);
+}
+function calcProsePlugins(getHooks) {
+  const plugin = $prose(
+    () => new Plugin({
+      key: calcDecorationKey,
+      state: {
+        init: (_config, state) => buildCalcDecorations(state.doc, getHooks()),
+        apply: (tr, value, _old, newState) => tr.docChanged ? buildCalcDecorations(newState.doc, getHooks()) : value
+      },
+      props: {
+        decorations(state) {
+          return calcDecorationKey.getState(state);
+        }
+      }
+    })
+  );
+  return [plugin];
+}
+
+// src/lib/editor-completions.ts
+function triggerQueryStart(lineText, column, triggerCharacters) {
+  if (!triggerCharacters || triggerCharacters.length === 0) return null;
+  const before = lineText.slice(0, Math.max(0, column - 1));
+  let bestIndex = -1;
+  for (const ch of triggerCharacters) {
+    if (!ch) continue;
+    const idx = before.lastIndexOf(ch);
+    if (idx > bestIndex) bestIndex = idx;
+  }
+  if (bestIndex === -1) return null;
+  return bestIndex + 2;
+}
+function resolveReplaceRange(item, position, lineText, triggerCharacters) {
+  const start = item.replaceFrom ?? triggerQueryStart(lineText, position.column, triggerCharacters) ?? position.column;
+  return {
+    startLineNumber: position.lineNumber,
+    // Clamp into [1, column] — a bad/stale `replaceFrom` degrades to "insert at
+    // caret" rather than producing a backwards/out-of-range edit.
+    startColumn: Math.min(Math.max(1, start), position.column),
+    endLineNumber: position.lineNumber,
+    endColumn: position.column
+  };
+}
+async function collectCompletions(providers, ctx2) {
+  const perProvider = await Promise.all(
+    providers.map(async (provider) => {
+      try {
+        const items = await provider.provide(ctx2) ?? [];
+        return items.map((item) => ({ provider, item }));
+      } catch {
+        return [];
+      }
+    })
+  );
+  return perProvider.flat();
+}
+
+// src/lib/editor-content-access-prose.ts
+import { Plugin as Plugin2, PluginKey as PluginKey2 } from "@milkdown/kit/prose/state";
+import { $prose as $prose2 } from "@milkdown/kit/utils";
+var SELECTION_WATCH_KEY = new PluginKey2("editorContentAccess_selectionWatch");
+function selectionWatchPlugin(getListeners, getSerializeSlice) {
+  const plugin = $prose2(
+    () => new Plugin2({
+      key: SELECTION_WATCH_KEY,
+      view() {
+        return {
+          update(view, prevState) {
+            const ls = getListeners();
+            if (ls.size === 0) return;
+            if (prevState.selection.eq(view.state.selection)) return;
+            const { selection } = view.state;
+            const text = selection.empty ? "" : getSerializeSlice()(view);
+            const sel = { text, empty: selection.empty };
+            ls.forEach((l) => l(sel));
+          }
+        };
+      }
+    })
+  );
+  return plugin;
+}
+function proseMirrorContentAccess(deps, options = {}) {
+  const { getView, getText, serializeSlice, parseAndReplace, listeners } = deps;
+  const plainText2 = options.fidelity === "plainText";
+  function readSelection(view) {
+    const { selection } = view.state;
+    if (selection.empty) return { text: "", empty: true };
+    const text = plainText2 ? view.state.doc.textBetween(selection.from, selection.to, "\n") : serializeSlice(view);
+    return { text, empty: false };
+  }
+  const apply = (text) => {
+    const view = getView();
+    if (!view) return;
+    try {
+      if (plainText2) {
+        view.dispatch(view.state.tr.insertText(text).scrollIntoView());
+      } else {
+        parseAndReplace(view, text);
+      }
+    } catch {
+    }
+  };
+  return {
+    getText,
+    getSelection() {
+      const view = getView();
+      if (!view) return { text: "", empty: true };
+      return readSelection(view);
+    },
+    replaceSelection: apply,
+    insertAtCursor: apply,
+    focus() {
+      getView()?.focus();
+    },
+    onSelectionChange(listener2) {
+      listeners.add(listener2);
+      return () => listeners.delete(listener2);
+    }
+  };
+}
+
+// src/lib/markdown/markdown-scale.ts
+import {
+  PROSE_HEADING_REM,
+  PROSE_HEADING_TRACKING,
+  PROSE_HEADING_WEIGHT
+} from "@elabs-ai/components-ui";
+var MARKDOWN_HEADING_REM = PROSE_HEADING_REM;
+var MARKDOWN_HEADING_WEIGHT = PROSE_HEADING_WEIGHT;
+var MARKDOWN_HEADING_TRACKING = PROSE_HEADING_TRACKING;
+var MARKDOWN_MEASURE = "48rem";
+function markdownScaleVars() {
+  return {
+    "--md-h1": `${MARKDOWN_HEADING_REM[1]}rem`,
+    "--md-h2": `${MARKDOWN_HEADING_REM[2]}rem`,
+    "--md-h3": `${MARKDOWN_HEADING_REM[3]}rem`,
+    "--md-h4": `${MARKDOWN_HEADING_REM[4]}rem`,
+    "--md-h5": `${MARKDOWN_HEADING_REM[5]}rem`,
+    "--md-h6": `${MARKDOWN_HEADING_REM[6]}rem`,
+    "--md-heading-weight": String(MARKDOWN_HEADING_WEIGHT),
+    "--md-heading-tracking": MARKDOWN_HEADING_TRACKING,
+    "--md-measure": MARKDOWN_MEASURE
+  };
+}
+
+// src/markdown-iteration/edit-context.ts
+import { createContext } from "react";
+var IterationEditContext = createContext(null);
+
+// src/lib/markdown/frontmatter.ts
+import { dump, load } from "js-yaml";
+var FRONTMATTER_RE = /^\uFEFF?---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/;
+function parseFrontmatter(source) {
+  const match = source.match(FRONTMATTER_RE);
+  if (!match) {
+    return { frontmatter: {}, content: source, hasFrontmatter: false };
+  }
+  const parsed = load(match[1] ?? "");
+  const frontmatter = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  return {
+    frontmatter,
+    content: source.slice(match[0].length),
+    hasFrontmatter: true
+  };
+}
+function serializeFrontmatter(frontmatter, content) {
+  const body = content.replace(/^\s+/, "");
+  if (!frontmatter || Object.keys(frontmatter).length === 0) {
+    return body;
+  }
+  const yaml = dump(frontmatter, { lineWidth: -1, noRefs: true }).trimEnd();
+  return `---
+${yaml}
+---
+
+${body}`;
+}
+
+// src/lib/markdown/slugify.ts
+function plainText(raw) {
+  return raw.replace(/!\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/[`*_~]/g, "").trim();
+}
+function slugifyHeading(text) {
+  return text.toLowerCase().replace(/[^\p{L}\p{N}\s-]/gu, "").trim().replace(/\s+/g, "-") || "section";
+}
+function uniqueSlug(base, used) {
+  const seen = used.get(base) ?? 0;
+  used.set(base, seen + 1);
+  return seen === 0 ? base : `${base}-${seen}`;
+}
+
+// src/markdown-outline/markdown-outline.ts
+var HEADING_RE = /^(#{1,6})\s+(.*?)\s*#*\s*$/;
+var FENCE_RE = /^(```|~~~)/;
+function parseMarkdownOutline(markdown) {
+  let body = markdown;
+  try {
+    body = parseFrontmatter(markdown).content;
+  } catch {
+  }
+  const lines = body.split("\n");
+  const items = [];
+  const used = /* @__PURE__ */ new Map();
+  let inFence = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (FENCE_RE.test(line.trimStart())) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence) continue;
+    const match = HEADING_RE.exec(line);
+    if (!match) continue;
+    const text = plainText(match[2] ?? "");
+    if (!text) continue;
+    const base = slugifyHeading(text);
+    const id = uniqueSlug(base, used);
+    items.push({
+      id,
+      text,
+      level: match[1].length,
+      line: i + 1
+    });
+  }
+  return items;
+}
+
+// src/markdown-outline/document-outline.tsx
+import { cn as cn2 } from "@elabs-ai/components-ui/lib/cn";
+import { forwardRef as forwardRef2, useMemo } from "react";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function useMarkdownOutline(markdown) {
+  return useMemo(() => parseMarkdownOutline(markdown), [markdown]);
+}
+var DocumentOutline = forwardRef2(
+  function DocumentOutline2({ items, activeId, onSelect, itemActions, className, ...props }, ref) {
+    const minLevel = items.reduce((min, it) => Math.min(min, it.level), 6);
+    return /* @__PURE__ */ jsxs2(
+      "nav",
+      {
+        ref,
+        "aria-label": "Document outline",
+        className: cn2("text-body", className),
+        ...props,
+        children: [
+          /* @__PURE__ */ jsx3("ul", { className: "m-0 list-none border-s border-border p-0", children: items.map((item) => {
+            const actions = itemActions?.(item);
+            return /* @__PURE__ */ jsxs2("li", { className: cn2(actions && "group/outline-item relative"), children: [
+              /* @__PURE__ */ jsx3(
+                "button",
+                {
+                  type: "button",
+                  "aria-current": item.id === activeId ? "true" : void 0,
+                  onClick: () => onSelect?.(item),
+                  className: cn2(
+                    "-ms-px block w-full truncate border-s-2 py-1 pe-2 text-start text-caption",
+                    "transition-colors duration-fast ease-standard motion-reduce:transition-none",
+                    "focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring",
+                    item.id === activeId ? "border-s-primary font-medium text-foreground" : "border-s-transparent text-muted-foreground hover:border-s-border-strong hover:text-foreground",
+                    actions && "pe-8"
+                  ),
+                  style: { paddingInlineStart: `${(item.level - minLevel) * 0.875 + 0.75}rem` },
+                  children: item.text
+                }
+              ),
+              actions ? /* @__PURE__ */ jsx3("span", { className: "absolute end-0.5 top-1/2 -translate-y-1/2 opacity-0 transition-opacity duration-fast ease-standard focus-within:opacity-100 group-hover/outline-item:opacity-100 has-[[aria-pressed=true]]:opacity-100 motion-reduce:transition-none", children: actions }) : null
+            ] }, item.id);
+          }) }),
+          items.length === 0 ? /* @__PURE__ */ jsx3("p", { className: "px-2 py-1 text-caption text-muted-foreground", children: "No headings yet." }) : null
+        ]
+      }
+    );
+  }
+);
+
+// src/markdown-iteration/iteration.tsx
+import {
+  BentoGrid,
+  BentoGridItem,
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow
+} from "@elabs-ai/components-ui";
+import { cn as cn3 } from "@elabs-ai/components-ui/lib/cn";
+import { Repeat2 } from "lucide-react";
+import { forwardRef as forwardRef3 } from "react";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var TOKEN_RE = /\{\{\s*([\w.$]+)\s*\}\}/g;
+function defaultInterpolate(template, context) {
+  return template.replace(TOKEN_RE, (match, path) => {
+    const value = path.split(".").reduce((obj, key) => {
+      if (obj && typeof obj === "object") return obj[key];
+      return void 0;
+    }, context);
+    return value == null ? match : String(value);
+  });
+}
+function cellScope(spec, cell, index) {
+  return {
+    ...cell.context,
+    [spec.as]: cell.context,
+    index,
+    row: cell.row,
+    col: cell.col
+  };
+}
+function safeEvaluate(evaluate, spec) {
+  try {
+    return evaluate(spec);
+  } catch {
+    return null;
+  }
+}
+function chunk(arr, size) {
+  if (size <= 0) return [arr];
+  const out = [];
+  for (let i = 0; i < arr.length; i += size) out.push(arr.slice(i, i + size));
+  return out;
+}
+function bentoSize(index) {
+  const m = index % 6;
+  if (m === 0) return "lg";
+  if (m === 3) return "md";
+  return "sm";
+}
+var IterationBlock = forwardRef3(
+  function IterationBlock2({
+    spec,
+    evaluate,
+    interpolate = defaultInterpolate,
+    render,
+    layout,
+    emptyLabel,
+    className,
+    ...props
+  }, ref) {
+    const data = safeEvaluate(evaluate, spec);
+    const cells = data?.cells ?? [];
+    const resolvedLayout = layout ?? spec.layout;
+    const renderCell = (cell, index) => {
+      const md = cell.markdown ?? interpolate(spec.template, cellScope(spec, cell, index));
+      return render(md);
+    };
+    const label = spec.kind === "pivot" ? "Pivot" : "Iteration";
+    if (cells.length === 0) {
+      return /* @__PURE__ */ jsxs3(
+        "div",
+        {
+          ref,
+          role: "group",
+          "aria-label": label,
+          "data-iteration": spec.kind,
+          className: cn3("my-4 flex items-center gap-2 text-meta text-muted-foreground", className),
+          ...props,
+          children: [
+            /* @__PURE__ */ jsx4(Repeat2, { className: "size-4 shrink-0", "aria-hidden": "true" }),
+            /* @__PURE__ */ jsx4("span", { children: emptyLabel ?? `Nothing to ${spec.kind === "pivot" ? "pivot" : "iterate"} yet.` })
+          ]
+        }
+      );
+    }
+    const isMatrix = resolvedLayout === "matrix" && !!data?.rowHeaders?.length && !!data?.colHeaders?.length;
+    let body;
+    if (resolvedLayout === "stacked") {
+      body = /* @__PURE__ */ jsx4("ol", { className: "space-y-6", children: cells.map((cell, i) => /* @__PURE__ */ jsx4("li", { className: "[&>*:first-child]:mt-0 [&>*:last-child]:mb-0", children: renderCell(cell, i) }, cell.key ?? i)) });
+    } else if (resolvedLayout === "bento") {
+      body = /* @__PURE__ */ jsx4(BentoGrid, { children: cells.map((cell, i) => /* @__PURE__ */ jsx4(BentoGridItem, { size: cell.size ?? bentoSize(i), children: /* @__PURE__ */ jsx4("div", { className: "h-full overflow-auto p-4 [&>*:first-child]:mt-0 [&>*:last-child]:mb-0", children: renderCell(cell, i) }) }, cell.key ?? i)) });
+    } else if (isMatrix) {
+      const rowHeaders = data.rowHeaders;
+      const colHeaders = data.colHeaders;
+      const at = /* @__PURE__ */ new Map();
+      cells.forEach((cell, i) => {
+        if (cell.row != null && cell.col != null)
+          at.set(JSON.stringify([cell.row, cell.col]), { cell, index: i });
+      });
+      body = /* @__PURE__ */ jsxs3(Table, { children: [
+        /* @__PURE__ */ jsx4(TableHeader, { children: /* @__PURE__ */ jsxs3(TableRow, { children: [
+          /* @__PURE__ */ jsx4(TableHead, { "aria-hidden": "true" }),
+          colHeaders.map((c) => /* @__PURE__ */ jsx4(TableHead, { scope: "col", children: c }, c))
+        ] }) }),
+        /* @__PURE__ */ jsx4(TableBody, { children: rowHeaders.map((r) => /* @__PURE__ */ jsxs3(TableRow, { children: [
+          /* @__PURE__ */ jsx4(TableHead, { scope: "row", className: "font-medium text-foreground", children: r }),
+          colHeaders.map((c) => {
+            const hit = at.get(JSON.stringify([r, c]));
+            return /* @__PURE__ */ jsx4(TableCell, { className: "align-top", children: hit ? renderCell(hit.cell, hit.index) : null }, c);
+          })
+        ] }, r)) })
+      ] });
+    } else {
+      const headers = data?.columns;
+      const colCount = (headers?.length ?? spec.columns ?? Math.min(cells.length, 3)) || 1;
+      const rows = chunk(cells, colCount);
+      body = /* @__PURE__ */ jsxs3(Table, { children: [
+        headers ? /* @__PURE__ */ jsx4(TableHeader, { children: /* @__PURE__ */ jsx4(TableRow, { children: headers.map((h) => /* @__PURE__ */ jsx4(TableHead, { scope: "col", children: h }, h)) }) }) : null,
+        /* @__PURE__ */ jsx4(TableBody, { children: rows.map((row, r) => /* @__PURE__ */ jsx4(TableRow, { children: row.map((cell, c) => /* @__PURE__ */ jsx4(TableCell, { className: "align-top", children: renderCell(cell, r * colCount + c) }, cell.key ?? c)) }, r)) })
+      ] });
+    }
+    return /* @__PURE__ */ jsx4(
+      "div",
+      {
+        ref,
+        role: "group",
+        "aria-label": label,
+        "data-iteration": spec.kind,
+        "data-iteration-layout": resolvedLayout,
+        className: cn3("my-4", className),
+        ...props,
+        children: body
+      }
+    );
+  }
+);
+
+// src/markdown-iteration/iteration-builder.ts
+var DEFAULT_LAYOUT = {
+  iterate: "stacked",
+  pivot: "matrix"
+};
+var ITERATION_LAYOUTS = {
+  iterate: ["stacked", "grid", "bento"],
+  pivot: ["matrix", "grid", "bento"]
+};
+var DEFAULT_TEMPLATE = {
+  iterate: "{{item.name}}",
+  pivot: "{{row}} \xB7 {{col}}"
+};
+function splitList(value) {
+  return (value ?? "").split(",").map((v) => v.trim()).filter((v) => v.length > 0);
+}
+function parseAttributes(attrString2) {
+  const out = {};
+  const re = /([\w-]+)\s*=\s*"([^"]*)"/g;
+  let m;
+  while (m = re.exec(attrString2)) {
+    const key = m[1];
+    if (key) out[key] = m[2] ?? "";
+  }
+  return out;
+}
+function attrString(attrs) {
+  return Object.entries(attrs).filter(([, v]) => v != null && v !== "").map(([k, v]) => `${k}="${String(v).replace(/"/g, "'")}"`).join(" ");
+}
+function directivePartsFromValue(value) {
+  const attributes = value.kind === "pivot" ? {
+    layout: value.layout,
+    rows: value.values.join(", "),
+    cols: (value.cols ?? []).join(", ")
+  } : {
+    as: value.as || "item",
+    layout: value.layout,
+    values: value.values.join(", ")
+  };
+  return { attributes, template: value.template.trim() };
+}
+function maxColonRun(template) {
+  let max = 0;
+  const re = /^ {0,3}(:{3,})/;
+  for (const line of template.split(/\r?\n/)) {
+    const m = re.exec(line);
+    if (m && m[1].length > max) max = m[1].length;
+  }
+  return max;
+}
+function outerDirectiveFence(template) {
+  return ":".repeat(Math.max(3, maxColonRun(template) + 1));
+}
+function serializeIterationDirective(value) {
+  const { attributes, template } = directivePartsFromValue(value);
+  const fence = outerDirectiveFence(template);
+  return `${fence}${value.kind}{${attrString(attributes)}}
+${template}
+${fence}`;
+}
+function builderValueFromParts(kind, attributes, template) {
+  const layout = attributes.layout || DEFAULT_LAYOUT[kind];
+  if (kind === "pivot") {
+    return {
+      kind,
+      as: attributes.as?.trim() || "item",
+      layout,
+      values: splitList(attributes.rows),
+      cols: splitList(attributes.cols),
+      template: template.trim() || DEFAULT_TEMPLATE.pivot
+    };
+  }
+  return {
+    kind,
+    as: attributes.as?.trim() || "item",
+    layout,
+    values: splitList(attributes.values),
+    template: template.trim() || DEFAULT_TEMPLATE.iterate
+  };
+}
+function parseIterationDirective(markdown) {
+  const m = markdown.match(/^(:{3,})(iterate|pivot)\{([^}]*)\}\n?([\s\S]*?)\n?\1\s*$/);
+  if (!m) return null;
+  return builderValueFromParts(
+    m[2],
+    parseAttributes(m[3] ?? ""),
+    m[4] ?? ""
+  );
+}
+function emptyBuilderValue(kind) {
+  return {
+    kind,
+    as: "item",
+    layout: DEFAULT_LAYOUT[kind],
+    values: [],
+    cols: kind === "pivot" ? [] : void 0,
+    template: DEFAULT_TEMPLATE[kind]
+  };
+}
+function evaluateEmbedded(spec) {
+  if (spec.kind === "pivot") {
+    const rows = splitList(spec.rows ?? spec.attributes.rows);
+    const cols = splitList(spec.cols ?? spec.attributes.cols);
+    if (rows.length === 0 || cols.length === 0) return { cells: [] };
+    const cells = rows.flatMap(
+      (row) => cols.map((col) => ({ context: { row, col }, row, col, key: `${row}|${col}` }))
+    );
+    return { cells, rowHeaders: rows, colHeaders: cols };
+  }
+  const values = splitList(spec.attributes.values ?? spec.source);
+  if (values.length === 0) return { cells: [] };
+  return {
+    cells: values.map((value, i) => ({ context: { value, name: value }, key: `${i}:${value}` }))
+  };
+}
+function transposeIterationValue(value) {
+  if (value.kind !== "pivot") return value;
+  return { ...value, values: value.cols ?? [], cols: value.values };
+}
+function cellScope2(as, cell, index) {
+  return { ...cell.context, [as]: cell.context, index, row: cell.row, col: cell.col };
+}
+function escapeTableCell(markdown) {
+  return markdown.replace(/\|/g, "\\|").replace(/\r?\n+/g, " ").trim();
+}
+function staticMarkdownFromValue(value, interpolate = defaultInterpolate) {
+  const { attributes } = directivePartsFromValue(value);
+  const spec = {
+    kind: value.kind,
+    layout: value.layout,
+    template: value.template,
+    as: value.as,
+    attributes
+  };
+  const data = evaluateEmbedded(spec);
+  if (data.cells.length === 0) return "";
+  const cellMarkdown = (cell, index) => interpolate(value.template, cellScope2(value.as, cell, index)).trim();
+  if (value.layout === "matrix" && data.rowHeaders?.length && data.colHeaders?.length) {
+    const rowHeaders = data.rowHeaders;
+    const colHeaders = data.colHeaders;
+    const at = /* @__PURE__ */ new Map();
+    data.cells.forEach((cell, i) => {
+      if (cell.row != null && cell.col != null) {
+        at.set(`${cell.row}|${cell.col}`, cellMarkdown(cell, i));
+      }
+    });
+    const headerRow = ["", ...colHeaders.map(escapeTableCell)];
+    const dividerRow = headerRow.map(() => "---");
+    const bodyRows = rowHeaders.map((row) => [
+      escapeTableCell(row),
+      ...colHeaders.map((col) => escapeTableCell(at.get(`${row}|${col}`) ?? ""))
+    ]);
+    return [headerRow, dividerRow, ...bodyRows].map((r) => `| ${r.join(" | ")} |`).join("\n");
+  }
+  return data.cells.map((cell, i) => cellMarkdown(cell, i)).join("\n\n");
+}
+
+// src/metric-block/metric-block.tsx
+import { MetricCard } from "@elabs-ai/components-ui";
+var MetricBlock = MetricCard;
+
+// src/markdown-editor/slash/insert-directive.ts
+import { editorViewCtx, parserCtx } from "@milkdown/kit/core";
+import { Fragment } from "@milkdown/kit/prose/model";
+import { TextSelection } from "@milkdown/kit/prose/state";
+
+// src/markdown-editor/directive-nodes.ts
+import { $nodeSchema, $remark } from "@milkdown/kit/utils";
+import remarkDirective from "remark-directive";
+var directiveRemark = $remark("brandDirective", () => remarkDirective);
+var containerDirectiveSchema = $nodeSchema("brand_container_directive", () => ({
+  content: "block+",
+  group: "block",
+  defining: true,
+  attrs: {
+    name: { default: "card" },
+    attributes: { default: {} }
+  },
+  parseDOM: [
+    {
+      tag: "div[data-brand-directive]",
+      getAttrs: (dom) => {
+        if (typeof dom === "string") return false;
+        return {
+          name: dom.getAttribute("data-brand-directive") ?? "card",
+          attributes: JSON.parse(dom.getAttribute("data-brand-attrs") ?? "{}")
+        };
+      }
+    }
+  ],
+  toDOM: (node) => {
+    const name = String(node.attrs.name);
+    const attrs = node.attrs.attributes ?? {};
+    const heading = attrs.title || (name === "callout" ? attrs.type ?? "note" : "");
+    const chrome = [
+      "div",
+      {
+        "data-brand-directive": name,
+        "data-brand-attrs": JSON.stringify(attrs),
+        class: `brand-directive brand-directive--${name}`,
+        "data-callout-type": name === "callout" ? attrs.type ?? "note" : null
+      }
+    ];
+    if (heading)
+      chrome.push(["div", { class: "brand-directive__title", contenteditable: "false" }, heading]);
+    chrome.push(["div", { class: "brand-directive__body" }, 0]);
+    return chrome;
+  },
+  parseMarkdown: {
+    match: (node) => node.type === "containerDirective",
+    runner: (state, node, type) => {
+      const d = node;
+      state.openNode(type, { name: d.name ?? "card", attributes: d.attributes ?? {} });
+      state.next(d.children ?? []);
+      state.closeNode();
+    }
+  },
+  toMarkdown: {
+    match: (node) => node.type.name === "brand_container_directive",
+    runner: (state, node) => {
+      state.openNode("containerDirective", void 0, {
+        name: node.attrs.name,
+        attributes: node.attrs.attributes
+      });
+      state.next(node.content);
+      state.closeNode();
+    }
+  }
+}));
+var leafDirectiveSchema = $nodeSchema("brand_leaf_directive", () => ({
+  group: "block",
+  atom: true,
+  isolating: true,
+  attrs: {
+    name: { default: "metric" },
+    attributes: { default: {} }
+  },
+  parseDOM: [
+    {
+      tag: "div[data-brand-leaf]",
+      getAttrs: (dom) => {
+        if (typeof dom === "string") return false;
+        return {
+          name: dom.getAttribute("data-brand-leaf") ?? "metric",
+          attributes: JSON.parse(dom.getAttribute("data-brand-attrs") ?? "{}")
+        };
+      }
+    }
+  ],
+  toDOM: (node) => {
+    const name = String(node.attrs.name);
+    const a = node.attrs.attributes ?? {};
+    return [
+      "div",
+      {
+        "data-brand-leaf": name,
+        "data-brand-attrs": JSON.stringify(a),
+        class: `brand-directive brand-directive--leaf brand-directive--${name}`,
+        contenteditable: "false"
+      },
+      ["div", { class: "brand-metric__label" }, a.label ?? name],
+      ["div", { class: "brand-metric__value" }, a.value ?? ""],
+      ...a.description ? [["div", { class: "brand-metric__desc" }, a.description]] : []
+    ];
+  },
+  parseMarkdown: {
+    match: (node) => node.type === "leafDirective",
+    runner: (state, node, type) => {
+      const d = node;
+      state.addNode(type, { name: d.name ?? "metric", attributes: d.attributes ?? {} });
+    }
+  },
+  toMarkdown: {
+    match: (node) => node.type.name === "brand_leaf_directive",
+    runner: (state, node) => {
+      state.addNode("leafDirective", void 0, void 0, {
+        name: node.attrs.name,
+        attributes: node.attrs.attributes
+      });
+    }
+  }
+}));
+var directivePlugins = [
+  directiveRemark,
+  containerDirectiveSchema,
+  leafDirectiveSchema
+].flat();
+
+// src/markdown-editor/slash/insert-directive.ts
+var DIRECTIVE_DEFAULTS = {
+  card: { title: "Title" },
+  callout: { type: "info", title: "Note" },
+  timeline: {},
+  metric: { label: "Label", value: "0", description: "detail" },
+  iterate: { as: "item", layout: "stacked" },
+  pivot: { layout: "matrix" }
+};
+var DIRECTIVE_BODY_SEED = {
+  iterate: "{{item.name}}",
+  pivot: "{{cell}}"
+};
+var CONTAINER_DIRECTIVES = /* @__PURE__ */ new Set(["card", "callout", "timeline", "iterate", "pivot"]);
+var LEAF_DIRECTIVES = /* @__PURE__ */ new Set(["metric"]);
+function containerBody(schema, name) {
+  const paragraph = schema.nodes.paragraph;
+  if (name === "timeline") {
+    const bulletList = schema.nodes.bullet_list;
+    const listItem = schema.nodes.list_item;
+    if (bulletList && listItem && paragraph) {
+      const steps = ["(done) Step one", "(active) Step two", "(pending) Step three"];
+      const items = steps.map(
+        (text) => listItem.create(null, paragraph.create(null, schema.text(text)))
+      );
+      return Fragment.from(bulletList.create(null, items));
+    }
+  }
+  const seed = DIRECTIVE_BODY_SEED[name];
+  if (seed && paragraph) return Fragment.from(paragraph.create(null, schema.text(seed)));
+  if (!paragraph) return Fragment.empty;
+  return Fragment.from(paragraph.create());
+}
+function insertBrandDirective(name, containerType, leafType, schema, range) {
+  return (state, dispatch) => {
+    const isContainer = CONTAINER_DIRECTIVES.has(name);
+    const isLeaf = LEAF_DIRECTIVES.has(name);
+    if (!isContainer && !isLeaf) return false;
+    const attributes = { ...DIRECTIVE_DEFAULTS[name] ?? {} };
+    const node = isContainer ? containerType.create({ name, attributes }, containerBody(schema, name)) : leafType.create({ name, attributes });
+    if (!node) return false;
+    if (!dispatch) return true;
+    const { from, to } = range ?? { from: state.selection.from, to: state.selection.to };
+    const tr = state.tr.replaceRangeWith(from, to, node);
+    const caret = isContainer ? Math.min(from + 2, tr.doc.content.size) : Math.min(from + node.nodeSize, tr.doc.content.size);
+    const sel = TextSelection.near(tr.doc.resolve(caret), 1);
+    tr.setSelection(sel).scrollIntoView();
+    dispatch(tr);
+    return true;
+  };
+}
+function insertBasicBlock(id, schema, range) {
+  return (state, dispatch) => {
+    const n = schema.nodes;
+    const { from, to } = range ?? { from: state.selection.from, to: state.selection.to };
+    const tr = state.tr;
+    const replaceWith = (node, caretOffset) => {
+      if (!node) return false;
+      if (!dispatch) return true;
+      tr.replaceRangeWith(from, to, node);
+      const caret = Math.min(from + caretOffset, tr.doc.content.size);
+      tr.setSelection(TextSelection.near(tr.doc.resolve(caret), 1)).scrollIntoView();
+      dispatch(tr);
+      return true;
+    };
+    switch (id) {
+      case "heading":
+        return replaceWith(n.heading?.create({ level: 2 }) ?? null, 1);
+      case "bullet-list": {
+        const li = n.list_item?.create(null, n.paragraph?.create());
+        return replaceWith(li ? n.bullet_list?.create(null, li) ?? null : null, 2);
+      }
+      case "ordered-list": {
+        const li = n.list_item?.create(null, n.paragraph?.create());
+        return replaceWith(li ? n.ordered_list?.create(null, li) ?? null : null, 2);
+      }
+      case "quote":
+        return replaceWith(n.blockquote?.create(null, n.paragraph?.create()) ?? null, 2);
+      case "code":
+        return replaceWith(n.code_block?.create() ?? null, 1);
+      case "divider": {
+        const hr = n.hr ?? n.horizontal_rule;
+        if (!hr) return false;
+        if (!dispatch) return true;
+        const node = hr.create();
+        tr.replaceRangeWith(from, to, node);
+        const para = n.paragraph?.create();
+        if (para) tr.insert(from + node.nodeSize, para);
+        const caret = Math.min(from + node.nodeSize + 1, tr.doc.content.size);
+        tr.setSelection(TextSelection.near(tr.doc.resolve(caret), 1)).scrollIntoView();
+        dispatch(tr);
+        return true;
+      }
+      default:
+        return false;
+    }
+  };
+}
+var CALC_FENCE_SEED = ["items = 3", "price = 4.50", "total = items * price"].join("\n");
+function insertCalcFence(schema, range, seed = CALC_FENCE_SEED) {
+  return (state, dispatch) => {
+    const codeBlock = schema.nodes.code_block;
+    if (!codeBlock) return false;
+    const node = seed ? codeBlock.create({ language: "calc" }, schema.text(seed)) : codeBlock.create({ language: "calc" });
+    if (!node) return false;
+    if (!dispatch) return true;
+    const { from, to } = range ?? { from: state.selection.from, to: state.selection.to };
+    const tr = state.tr.replaceRangeWith(from, to, node);
+    const caret = Math.min(from + 1, tr.doc.content.size);
+    tr.setSelection(TextSelection.near(tr.doc.resolve(caret), 1)).scrollIntoView();
+    dispatch(tr);
+    return true;
+  };
+}
+function resolveCalcInsert(ctx2, range) {
+  const view = ctx2.get(editorViewCtx);
+  const command = insertCalcFence(view.state.schema, range);
+  return command(view.state, view.dispatch.bind(view));
+}
+function resolveBrandInsert(ctx2, name, range) {
+  const view = ctx2.get(editorViewCtx);
+  const containerType = containerDirectiveSchema.type(ctx2);
+  const leafType = leafDirectiveSchema.type(ctx2);
+  const schema = view.state.schema;
+  const command = insertBrandDirective(name, containerType, leafType, schema, range);
+  return command(view.state, view.dispatch.bind(view));
+}
+function resolveBasicInsert(ctx2, id, range) {
+  const view = ctx2.get(editorViewCtx);
+  const command = insertBasicBlock(id, view.state.schema, range);
+  return command(view.state, view.dispatch.bind(view));
+}
+function insertParsedMarkdown(ctx2, markdown, range) {
+  try {
+    const view = ctx2.get(editorViewCtx);
+    const parse = ctx2.get(parserCtx);
+    const parsed = parse(markdown);
+    if (!parsed) return false;
+    const { from, to } = range ?? { from: view.state.selection.from, to: view.state.selection.to };
+    const tr = view.state.tr.replaceWith(from, to, parsed.content);
+    const caret = Math.min(from + 2, tr.doc.content.size);
+    tr.setSelection(TextSelection.near(tr.doc.resolve(caret), 1)).scrollIntoView();
+    view.dispatch(tr);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveGuidedIterationInsert(ctx2, kind, range, handler) {
+  const seed = emptyBuilderValue(kind);
+  handler({
+    kind,
+    template: seed.template,
+    attributes: {},
+    onSave: (template) => {
+      const value = builderValueFromParts(kind, {}, template);
+      insertParsedMarkdown(ctx2, serializeIterationDirective(value), range);
+    },
+    onSaveData: ({ attributes, template }) => {
+      const value = builderValueFromParts(kind, attributes, template);
+      insertParsedMarkdown(ctx2, serializeIterationDirective(value), range);
+    }
+  });
+}
+
+// src/markdown-editor/slash/brand-slash-commands.ts
+import {
+  Calculator,
+  Grid3x3,
+  Heading2,
+  List,
+  ListOrdered,
+  Minus,
+  Quote,
+  Repeat2 as Repeat22,
+  SquareCode
+} from "lucide-react";
+import { createElement } from "react";
+function glyph(icon) {
+  return createElement(icon, { className: "size-4", "aria-hidden": "true" });
+}
+var DIRECTIVE_SNIPPET = {
+  card: `:::card{title="Title"}
+Content
+:::`,
+  callout: `:::callout{type="info" title="Note"}
+Message
+:::`,
+  metric: `::metric{label="Label" value="0" description="detail"}`,
+  timeline: `:::timeline
+- (done) Step one
+- (active) Step two
+- (pending) Step three
+:::`,
+  iterate: `:::iterate{as="item" layout="stacked"}
+{{item.name}}
+:::`,
+  pivot: `:::pivot{layout="matrix"}
+{{cell}}
+:::`
+};
+var GUIDED_DIRECTIVES = /* @__PURE__ */ new Set(["iterate", "pivot"]);
+function brandCommand(name, label, description, keywords, icon) {
+  const command = {
+    id: `brand-${name}`,
+    label,
+    group: "Brand blocks",
+    description,
+    keywords,
+    icon,
+    snippet: DIRECTIVE_SNIPPET[name],
+    run: ({ ctx: ctx2, range }) => resolveBrandInsert(ctx2, name, range)
+  };
+  if (GUIDED_DIRECTIVES.has(name)) {
+    command.guided = ({ ctx: ctx2, range }, handler) => resolveGuidedIterationInsert(ctx2, name, range, handler);
+  }
+  return command;
+}
+function basicCommand(id, label, description, keywords, icon) {
+  return {
+    id: `basic-${id}`,
+    label,
+    group: "Basic",
+    description,
+    keywords,
+    icon: glyph(icon),
+    run: ({ ctx: ctx2, range }) => resolveBasicInsert(ctx2, id, range)
+  };
+}
+var BRAND_SLASH_COMMANDS = [
+  brandCommand(
+    "card",
+    "Card",
+    "A titled content card",
+    ["card", "panel", "box", "section"],
+    glyph(SquareCode)
+  ),
+  brandCommand(
+    "callout",
+    "Callout",
+    "A highlighted note / alert",
+    ["callout", "alert", "note", "info", "warning", "tip"],
+    glyph(Quote)
+  ),
+  brandCommand(
+    "metric",
+    "Metric",
+    "A single KPI value",
+    ["metric", "kpi", "stat", "number", "value"],
+    glyph(Minus)
+  ),
+  brandCommand(
+    "timeline",
+    "Timeline",
+    "A list of steps with status",
+    ["timeline", "steps", "milestones", "roadmap", "progress"],
+    glyph(List)
+  ),
+  brandCommand(
+    "iterate",
+    "Iterate",
+    "Repeat a template per data row",
+    ["iterate", "repeat", "loop", "for-each", "foreach", "map", "list", "template"],
+    glyph(Repeat22)
+  ),
+  brandCommand(
+    "pivot",
+    "Pivot",
+    "A row \xD7 column cross-tab",
+    ["pivot", "matrix", "cross-tab", "crosstab", "table", "grid"],
+    glyph(Grid3x3)
+  ),
+  {
+    // Inserts a ```calc fence (not a `:::` directive), so it runs its own command
+    // rather than `resolveBrandInsert`. Highlight + result inlays come from the
+    // editor's calc hooks; the fence is harmless when none are wired.
+    id: "brand-calc",
+    label: "Calc",
+    group: "Brand blocks",
+    description: "A live calculation block",
+    keywords: ["calc", "calculation", "math", "formula", "sum", "ledger", "budget"],
+    icon: glyph(Calculator),
+    snippet: ["```calc", CALC_FENCE_SEED, "```"].join("\n"),
+    run: ({ ctx: ctx2, range }) => resolveCalcInsert(ctx2, range)
+  },
+  basicCommand("heading", "Heading", "Section heading", ["heading", "title", "h2"], Heading2),
+  basicCommand(
+    "bullet-list",
+    "Bullet list",
+    "An unordered list",
+    ["bullet", "list", "unordered", "ul"],
+    List
+  ),
+  basicCommand(
+    "ordered-list",
+    "Numbered list",
+    "An ordered list",
+    ["numbered", "ordered", "list", "ol"],
+    ListOrdered
+  ),
+  basicCommand("quote", "Quote", "A block quotation", ["quote", "blockquote", "citation"], Quote),
+  basicCommand(
+    "code",
+    "Code block",
+    "A fenced code block",
+    ["code", "snippet", "pre", "fence"],
+    SquareCode
+  ),
+  basicCommand(
+    "divider",
+    "Divider",
+    "A horizontal rule",
+    ["divider", "rule", "hr", "separator"],
+    Minus
+  )
+];
+function filterSlashCommands(commands, query) {
+  const q = query.trim().toLowerCase();
+  if (!q) return commands;
+  return commands.filter((c) => {
+    if (c.label.toLowerCase().includes(q)) return true;
+    return (c.keywords ?? []).some((k) => k.toLowerCase().includes(q));
+  });
+}
+function groupSlashCommands(commands) {
+  const order = [];
+  const byGroup = /* @__PURE__ */ new Map();
+  for (const c of commands) {
+    const g = c.group ?? "Other";
+    if (!byGroup.has(g)) {
+      byGroup.set(g, []);
+      order.push(g);
+    }
+    byGroup.get(g).push(c);
+  }
+  return order.map((group) => ({ group, commands: byGroup.get(group) }));
+}
+
+// src/markdown-editor/slash/slash-menu.tsx
+import { cn as cn4 } from "@elabs-ai/components-ui/lib/cn";
+import { forwardRef as forwardRef4 } from "react";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function slashOptionId(idPrefix, commandId) {
+  return `${idPrefix}-${commandId}`;
+}
+var SlashMenu = forwardRef4(function SlashMenu2({
+  commands,
+  activeId,
+  onSelect,
+  idPrefix = "brand-slash",
+  emptyLabel = "No matching blocks",
+  className,
+  ...props
+}, ref) {
+  const groups = groupSlashCommands(commands);
+  return /* @__PURE__ */ jsx5(
+    "div",
+    {
+      ref,
+      role: "listbox",
+      "aria-label": "Insert block",
+      className: cn4(
+        "max-h-[min(320px,60vh)] w-72 overflow-y-auto overflow-x-hidden rounded-md bg-popover p-1 text-popover-foreground shadow-ring-md",
+        className
+      ),
+      ...props,
+      children: commands.length === 0 ? /* @__PURE__ */ jsx5("div", { className: "px-2 py-6 text-center text-caption text-muted-foreground", children: emptyLabel }) : groups.map(({ group, commands: groupCommands }) => /* @__PURE__ */ jsxs4("div", { role: "group", "aria-label": group, className: "overflow-hidden p-1", children: [
+        /* @__PURE__ */ jsx5("div", { className: "px-2 py-1.5 text-meta font-medium text-muted-foreground", children: group }),
+        groupCommands.map((command) => {
+          const selected = command.id === activeId;
+          return /* @__PURE__ */ jsxs4(
+            "div",
+            {
+              id: slashOptionId(idPrefix, command.id),
+              role: "option",
+              "aria-selected": selected,
+              "data-selected": selected ? "true" : void 0,
+              onMouseDown: (e) => {
+                e.preventDefault();
+                onSelect(command);
+              },
+              className: cn4(
+                "flex cursor-default select-none items-center gap-2 rounded-sm px-2 py-1.5 text-body outline-none transition-colors duration-fast",
+                "data-[selected=true]:bg-accent data-[selected=true]:text-accent-foreground"
+              ),
+              children: [
+                command.icon ? /* @__PURE__ */ jsx5("span", { className: "flex size-5 shrink-0 items-center justify-center text-muted-foreground [&_svg]:size-4", children: command.icon }) : null,
+                /* @__PURE__ */ jsxs4("span", { className: "flex min-w-0 flex-col", children: [
+                  /* @__PURE__ */ jsx5("span", { className: "truncate", children: command.label }),
+                  command.description ? /* @__PURE__ */ jsx5("span", { className: "truncate text-meta text-muted-foreground", children: command.description }) : null
+                ] })
+              ]
+            },
+            command.id
+          );
+        })
+      ] }, group))
+    }
+  );
+});
+
+// src/markdown-editor/slash/brand-slash-plugin.ts
+import { $prose as $prose3 } from "@milkdown/kit/utils";
+import { Plugin as Plugin3, PluginKey as PluginKey3 } from "@milkdown/kit/prose/state";
+import { DecorationSet as DecorationSet2 } from "@milkdown/kit/prose/view";
+
+// src/markdown-editor/slash/shortcut.ts
+var DEFAULT_SLASH_SHORTCUT = "Mod-Shift-O";
+function matchesKeyboardEvent(shortcut, event) {
+  const parts = shortcut.split("-");
+  const keyPart = parts[parts.length - 1] ?? "";
+  const modifiers = new Set(parts.slice(0, -1).map((m) => m.toLowerCase()));
+  const wantsMod = modifiers.has("mod");
+  const wantsShift = modifiers.has("shift");
+  const wantsAlt = modifiers.has("alt");
+  if (wantsMod && !(event.metaKey || event.ctrlKey)) return false;
+  if (!wantsMod && (event.metaKey || event.ctrlKey)) return false;
+  if (wantsShift && !event.shiftKey) return false;
+  if (!wantsShift && event.shiftKey) return false;
+  if (wantsAlt && !event.altKey) return false;
+  if (!wantsAlt && event.altKey) return false;
+  return event.key.toLowerCase() === keyPart.toLowerCase();
+}
+
+// src/markdown-editor/slash/brand-slash-plugin.ts
+var CLOSED = {
+  active: false,
+  from: 0,
+  query: "",
+  index: 0,
+  triggered: "char"
+};
+var slashPluginKey = new PluginKey3("brand-slash");
+function createSlashController(commands, trigger = "/", shortcut, getIterationEditHandler) {
+  const controller = {
+    commands,
+    trigger,
+    shortcut,
+    getIterationEditHandler,
+    getCtx: () => {
+      if (!controller._ctx) {
+        throw new Error("Brand slash controller used before the editor Ctx was captured.");
+      }
+      return controller._ctx;
+    },
+    openMenu: (view) => {
+      const pos = view.state.selection.from;
+      view.dispatch(
+        view.state.tr.setMeta(slashPluginKey, {
+          _open: true,
+          from: pos,
+          triggered: "shortcut"
+        })
+      );
+    }
+  };
+  return controller;
+}
+function slashRange(state) {
+  return { from: state.from, to: state.from + 1 + state.query.length };
+}
+function runSlashCommand(view, controller, state, command) {
+  const range = state.triggered === "shortcut" ? { from: state.from, to: state.from + state.query.length } : slashRange(state);
+  const iterationHandler = controller.getIterationEditHandler?.();
+  if (command.guided && iterationHandler) {
+    view.dispatch(view.state.tr.delete(range.from, range.to));
+    command.guided({ ctx: controller.getCtx(), range: null }, iterationHandler);
+  } else {
+    command.run({ ctx: controller.getCtx(), range });
+  }
+  if (slashPluginKey.getState(view.state)?.active) {
+    view.dispatch(view.state.tr.setMeta(slashPluginKey, "close"));
+  }
+  view.focus();
+}
+function triggerAllowed(doc, triggerPos) {
+  const $pos = doc.resolve(triggerPos);
+  if (!$pos.parent.isTextblock) return false;
+  if ($pos.parent.type.spec.code) return false;
+  if ($pos.parentOffset === 0) return true;
+  const before = $pos.parent.textBetween(Math.max(0, $pos.parentOffset - 1), $pos.parentOffset);
+  return /\s/.test(before);
+}
+function nextState(prev, tr, trigger) {
+  const meta = tr.getMeta(slashPluginKey);
+  if (meta === "close") return CLOSED;
+  if (meta && typeof meta === "object") {
+    if (meta._open) {
+      return {
+        active: true,
+        from: meta.from,
+        query: "",
+        index: 0,
+        triggered: "shortcut"
+      };
+    }
+    return prev.active ? { ...prev, ...meta } : prev;
+  }
+  const sel = tr.selection;
+  if (!sel.empty) return prev.active ? CLOSED : prev;
+  const pos = sel.from;
+  const $pos = tr.doc.resolve(pos);
+  if (prev.active) {
+    if (pos <= prev.from) return CLOSED;
+    const start = tr.doc.resolve(prev.from);
+    if (start.parent !== $pos.parent) return CLOSED;
+    if (prev.triggered === "shortcut") {
+      const query2 = $pos.parent.textBetween(start.parentOffset, $pos.parentOffset);
+      if (/\s/.test(query2)) return CLOSED;
+      const index2 = query2 === prev.query ? prev.index : 0;
+      return { active: true, from: prev.from, query: query2, index: index2, triggered: "shortcut" };
+    }
+    const triggerChar = start.parent.textBetween(start.parentOffset, start.parentOffset + 1);
+    if (triggerChar !== trigger) return CLOSED;
+    const query = $pos.parent.textBetween(start.parentOffset + 1, $pos.parentOffset);
+    if (/\s/.test(query)) return CLOSED;
+    const index = query === prev.query ? prev.index : 0;
+    return { active: true, from: prev.from, query, index, triggered: "char" };
+  }
+  if (!tr.docChanged) return prev;
+  const justTyped = tr.doc.textBetween(Math.max(0, pos - 1), pos);
+  if (justTyped !== trigger) return prev;
+  const triggerPos = pos - 1;
+  if (!triggerAllowed(tr.doc, triggerPos)) return prev;
+  return { active: true, from: triggerPos, query: "", index: 0, triggered: "char" };
+}
+function brandSlashPlugin(options) {
+  const { widgetFactory, widgetComponent, controller } = options;
+  const trigger = controller.trigger || "/";
+  return $prose3((ctx2) => {
+    controller._ctx = ctx2;
+    return new Plugin3({
+      key: slashPluginKey,
+      state: {
+        init: () => CLOSED,
+        apply: (tr, value) => nextState(value, tr, trigger)
+      },
+      props: {
+        decorations: (state) => {
+          const s = slashPluginKey.getState(state);
+          if (!s?.active) return DecorationSet2.empty;
+          const factory = widgetFactory({ component: widgetComponent, as: "span" });
+          const anchor = s.triggered === "shortcut" ? s.from : s.from + 1;
+          const decoration = factory(anchor, {
+            side: 1,
+            ignoreSelection: true,
+            key: `brand-slash:${s.from}:${s.query}:${s.index}`
+          });
+          return DecorationSet2.create(state.doc, [decoration]);
+        },
+        handleKeyDown: (view, event) => {
+          if (controller.shortcut && matchesKeyboardEvent(controller.shortcut, event)) {
+            const pos = view.state.selection.from;
+            view.dispatch(
+              view.state.tr.setMeta(slashPluginKey, {
+                _open: true,
+                from: pos,
+                triggered: "shortcut"
+              })
+            );
+            event.preventDefault();
+            return true;
+          }
+          const s = slashPluginKey.getState(view.state);
+          if (!s?.active) return false;
+          const filtered = filterSlashCommands(controller.commands, s.query);
+          if (event.key === "Escape") {
+            view.dispatch(view.state.tr.setMeta(slashPluginKey, "close"));
+            event.preventDefault();
+            return true;
+          }
+          if (filtered.length === 0) return false;
+          if (event.key === "ArrowDown") {
+            const index = (s.index + 1) % filtered.length;
+            view.dispatch(view.state.tr.setMeta(slashPluginKey, { index }));
+            event.preventDefault();
+            return true;
+          }
+          if (event.key === "ArrowUp") {
+            const index = (s.index - 1 + filtered.length) % filtered.length;
+            view.dispatch(view.state.tr.setMeta(slashPluginKey, { index }));
+            event.preventDefault();
+            return true;
+          }
+          if (event.key === "Enter") {
+            const command = filtered[Math.min(s.index, filtered.length - 1)];
+            if (command) {
+              runSlashCommand(view, controller, s, command);
+              event.preventDefault();
+              return true;
+            }
+          }
+          if (event.key === "Tab") {
+            const command = filtered[Math.min(s.index, filtered.length - 1)];
+            if (command) {
+              runSlashCommand(view, controller, s, command);
+              event.preventDefault();
+              return true;
+            }
+          }
+          return false;
+        }
+      }
+    });
+  });
+}
+
+// src/markdown-editor/slash/slash-widget.tsx
+import { useWidgetViewContext } from "@prosemirror-adapter/react";
+import { useLayoutEffect, useRef as useRef2 } from "react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var ID_PREFIX = "brand-slash";
+function createSlashWidget(controller) {
+  function SlashWidget() {
+    const { view } = useWidgetViewContext();
+    const wrapperRef = useRef2(null);
+    const state = slashPluginKey.getState(view.state);
+    const query = state?.query ?? "";
+    const filtered = filterSlashCommands(controller.commands, query);
+    const activeIndex = state ? Math.min(state.index, Math.max(0, filtered.length - 1)) : 0;
+    const active = filtered[activeIndex];
+    const activeId = active?.id;
+    useLayoutEffect(() => {
+      const dom = view.dom;
+      const listEl = wrapperRef.current?.querySelector('[role="listbox"]');
+      if (listEl && !listEl.id) listEl.id = `${ID_PREFIX}-listbox`;
+      dom.setAttribute("aria-expanded", "true");
+      if (listEl) dom.setAttribute("aria-controls", listEl.id);
+      if (activeId) dom.setAttribute("aria-activedescendant", slashOptionId(ID_PREFIX, activeId));
+      else dom.removeAttribute("aria-activedescendant");
+      return () => {
+        dom.removeAttribute("aria-expanded");
+        dom.removeAttribute("aria-controls");
+        dom.removeAttribute("aria-activedescendant");
+      };
+    }, [view, activeId]);
+    useLayoutEffect(() => {
+      if (!activeId) return;
+      const el = wrapperRef.current?.querySelector(
+        `#${CSS.escape(slashOptionId(ID_PREFIX, activeId))}`
+      );
+      el?.scrollIntoView({ block: "nearest" });
+    }, [activeId]);
+    const onSelect = (command) => {
+      if (!state) return;
+      runSlashCommand(view, controller, state, command);
+    };
+    return (
+      // The widget anchor is zero-width inline; the menu floats below the caret.
+      /* @__PURE__ */ jsx6(
+        "span",
+        {
+          ref: wrapperRef,
+          contentEditable: false,
+          className: "brand-slash-anchor relative inline-block h-0 w-0 align-baseline",
+          children: /* @__PURE__ */ jsx6("span", { className: "absolute left-0 top-1 z-50 block", children: /* @__PURE__ */ jsx6(
+            SlashMenu,
+            {
+              commands: filtered,
+              activeId,
+              onSelect,
+              idPrefix: ID_PREFIX
+            }
+          ) })
+        }
+      )
+    );
+  }
+  return SlashWidget;
+}
+
+// src/markdown-editor/slash/index.ts
+function brandSlashViewPlugins(widgetFactory, options = {}) {
+  const commands = options.commands ?? BRAND_SLASH_COMMANDS;
+  const shortcut = "shortcut" in options ? options.shortcut : DEFAULT_SLASH_SHORTCUT;
+  const controller = createSlashController(
+    commands,
+    options.trigger ?? "/",
+    shortcut,
+    options.getIterationEditHandler
+  );
+  const widgetComponent = createSlashWidget(controller);
+  return [brandSlashPlugin({ widgetFactory, widgetComponent, controller })];
+}
+
+// src/markdown-editor/markdown-editor.tsx
+import "@milkdown/kit/prose/view/style/prosemirror.css";
+import {
+  Editor,
+  defaultValueCtx,
+  editorViewCtx as editorViewCtx3,
+  editorViewOptionsCtx,
+  parserCtx as parserCtx3,
+  rootCtx,
+  serializerCtx as serializerCtx2
+} from "@milkdown/kit/core";
+import { commonmark } from "@milkdown/kit/preset/commonmark";
+import { gfm } from "@milkdown/kit/preset/gfm";
+import { history } from "@milkdown/kit/plugin/history";
+import { listener, listenerCtx } from "@milkdown/kit/plugin/listener";
+import { TextSelection as TextSelection3 } from "@milkdown/kit/prose/state";
+import { getMarkdown, replaceAll } from "@milkdown/kit/utils";
+import { cn as cn8 } from "@elabs-ai/components-ui/lib/cn";
+import {
+  ProsemirrorAdapterProvider,
+  useNodeViewFactory,
+  usePluginViewFactory,
+  useWidgetViewFactory
+} from "@prosemirror-adapter/react";
+import {
+  forwardRef as forwardRef6,
+  useContext as useContext5,
+  useEffect as useEffect5,
+  useImperativeHandle as useImperativeHandle2,
+  useRef as useRef7
+} from "react";
+
+// src/markdown-editor/completions/completions-prose.ts
+import { Plugin as Plugin4, PluginKey as PluginKey4 } from "@milkdown/kit/prose/state";
+import { DecorationSet as DecorationSet3 } from "@milkdown/kit/prose/view";
+import { $prose as $prose4 } from "@milkdown/kit/utils";
+var CLOSED2 = {
+  active: false,
+  from: 0,
+  triggerChar: "",
+  query: "",
+  items: [],
+  index: 0,
+  requestId: 0
+};
+var completionsPluginKey = new PluginKey4("brand-completions");
+function nextCompletionState(prev, tr, triggerCharacters) {
+  const meta = tr.getMeta(completionsPluginKey);
+  if (meta === "close") return CLOSED2;
+  if (meta && typeof meta === "object") {
+    if (meta.type === "items") {
+      return prev.active && meta.requestId === prev.requestId ? { ...prev, items: meta.items } : prev;
+    }
+    if (meta.type === "nav") {
+      return prev.active ? { ...prev, index: meta.index } : prev;
+    }
+  }
+  const sel = tr.selection;
+  if (!sel.empty) return prev.active ? CLOSED2 : prev;
+  const pos = sel.from;
+  const isPureSingleCharInsert = tr.docChanged && tr.steps.length === 1 && tr.doc.content.size === tr.before.content.size + 1;
+  if (isPureSingleCharInsert) {
+    const justTyped = tr.doc.textBetween(Math.max(0, pos - 1), pos);
+    if (triggerCharacters.includes(justTyped)) {
+      return {
+        active: true,
+        from: pos - 1,
+        triggerChar: justTyped,
+        query: "",
+        items: [],
+        index: 0,
+        requestId: prev.requestId + 1
+      };
+    }
+  }
+  if (!prev.active) return prev;
+  if (pos <= prev.from) return CLOSED2;
+  const start = tr.doc.resolve(prev.from);
+  const $pos = tr.doc.resolve(pos);
+  if (start.parent !== $pos.parent) return CLOSED2;
+  const query = $pos.parent.textBetween(start.parentOffset + 1, $pos.parentOffset);
+  if (/\s/.test(query)) return CLOSED2;
+  if (query === prev.query) return prev;
+  return { ...prev, query, index: 0, requestId: prev.requestId + 1 };
+}
+function buildCompletionContext(doc, state) {
+  const resolved = doc.resolve(state.from);
+  const blockStart = resolved.pos - resolved.parentOffset;
+  const lineText = resolved.parent.textContent;
+  const caretPos = state.from + 1 + state.query.length;
+  const column = caretPos - blockStart + 1;
+  return { source: lineText, line: 1, column, lineText };
+}
+function completionReplaceRange(doc, state, item) {
+  const resolved = doc.resolve(state.from);
+  const blockStart = resolved.pos - resolved.parentOffset;
+  const lineText = resolved.parent.textContent;
+  const caretPos = state.from + 1 + state.query.length;
+  const column = caretPos - blockStart + 1;
+  const range = resolveReplaceRange(item, { lineNumber: 1, column }, lineText, [state.triggerChar]);
+  return {
+    from: blockStart + (range.startColumn - 1),
+    to: blockStart + (range.endColumn - 1)
+  };
+}
+function insertCompletionItem(view, state, item) {
+  const { from, to } = completionReplaceRange(view.state.doc, state, item);
+  view.dispatch(
+    view.state.tr.insertText(item.insertText, from, to).setMeta(completionsPluginKey, "close")
+  );
+  view.focus();
+}
+function completionsProsePlugin(options) {
+  const { widgetFactory, widgetComponent, getProviders } = options;
+  return $prose4(() => {
+    return new Plugin4({
+      key: completionsPluginKey,
+      state: {
+        init: () => CLOSED2,
+        apply: (tr, value) => {
+          const providers = getProviders() ?? [];
+          const triggerCharacters = Array.from(
+            new Set(providers.flatMap((p) => p.triggerCharacters ?? []))
+          );
+          return nextCompletionState(value, tr, triggerCharacters);
+        }
+      },
+      props: {
+        decorations: (state) => {
+          const s = completionsPluginKey.getState(state);
+          if (!s?.active) return DecorationSet3.empty;
+          const factory = widgetFactory({ component: widgetComponent, as: "span" });
+          const anchor = s.from + 1 + s.query.length;
+          const decoration = factory(anchor, {
+            side: 1,
+            ignoreSelection: true,
+            key: `brand-completions:${String(s.from)}:${s.query}:${String(s.items.length)}:${String(s.index)}`
+          });
+          return DecorationSet3.create(state.doc, [decoration]);
+        },
+        handleKeyDown: (view, event) => {
+          const s = completionsPluginKey.getState(view.state);
+          if (!s?.active) return false;
+          if (event.key === "Escape") {
+            view.dispatch(view.state.tr.setMeta(completionsPluginKey, "close"));
+            event.preventDefault();
+            return true;
+          }
+          if (s.items.length === 0) return false;
+          if (event.key === "ArrowDown") {
+            const index = (s.index + 1) % s.items.length;
+            view.dispatch(view.state.tr.setMeta(completionsPluginKey, { type: "nav", index }));
+            event.preventDefault();
+            return true;
+          }
+          if (event.key === "ArrowUp") {
+            const index = (s.index - 1 + s.items.length) % s.items.length;
+            view.dispatch(view.state.tr.setMeta(completionsPluginKey, { type: "nav", index }));
+            event.preventDefault();
+            return true;
+          }
+          if (event.key === "Enter" || event.key === "Tab") {
+            const item = s.items[Math.min(s.index, s.items.length - 1)];
+            if (item) {
+              insertCompletionItem(view, s, item);
+              event.preventDefault();
+              return true;
+            }
+          }
+          return false;
+        }
+      },
+      view: () => ({
+        update: (view, prevEditorState) => {
+          const state = completionsPluginKey.getState(view.state);
+          const prev = completionsPluginKey.getState(prevEditorState);
+          if (!state?.active) return;
+          if (prev?.active && prev.requestId === state.requestId) return;
+          const providers = (getProviders() ?? []).filter(
+            (p) => !p.triggerCharacters || p.triggerCharacters.includes(state.triggerChar)
+          );
+          if (providers.length === 0) return;
+          const ctx2 = buildCompletionContext(view.state.doc, state);
+          const requestId = state.requestId;
+          collectCompletions(providers, ctx2).then((matches) => {
+            if (view.isDestroyed) return;
+            const current = completionsPluginKey.getState(view.state);
+            if (!current?.active || current.requestId !== requestId) return;
+            view.dispatch(
+              view.state.tr.setMeta(completionsPluginKey, {
+                type: "items",
+                items: matches.map((m) => m.item),
+                requestId
+              })
+            );
+          }).catch(() => {
+          });
+        }
+      })
+    });
+  });
+}
+
+// src/markdown-editor/completions/completions-widget.tsx
+import { useWidgetViewContext as useWidgetViewContext2 } from "@prosemirror-adapter/react";
+import { useLayoutEffect as useLayoutEffect2, useRef as useRef3 } from "react";
+
+// src/markdown-editor/completions/completions-menu.tsx
+import { cn as cn5 } from "@elabs-ai/components-ui/lib/cn";
+import { forwardRef as forwardRef5 } from "react";
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+function completionOptionId(idPrefix, index) {
+  return `${idPrefix}-${index}`;
+}
+var CompletionMenu = forwardRef5(
+  function CompletionMenu2({
+    items,
+    activeIndex,
+    onSelect,
+    idPrefix = "brand-completions",
+    emptyLabel = "No suggestions",
+    className,
+    ...props
+  }, ref) {
+    return /* @__PURE__ */ jsx7(
+      "div",
+      {
+        ref,
+        role: "listbox",
+        "aria-label": "Suggestions",
+        className: cn5(
+          "max-h-[min(280px,50vh)] w-64 overflow-y-auto overflow-x-hidden rounded-md bg-popover p-1 text-popover-foreground shadow-ring-md",
+          className
+        ),
+        ...props,
+        children: items.length === 0 ? /* @__PURE__ */ jsx7("div", { className: "px-2 py-3 text-center text-caption text-muted-foreground", children: emptyLabel }) : items.map((item, index) => {
+          const selected = index === activeIndex;
+          return /* @__PURE__ */ jsx7(
+            "div",
+            {
+              id: completionOptionId(idPrefix, index),
+              role: "option",
+              "aria-selected": selected,
+              "data-selected": selected ? "true" : void 0,
+              onMouseDown: (e) => {
+                e.preventDefault();
+                onSelect(index);
+              },
+              className: cn5(
+                "flex cursor-default select-none items-center gap-2 rounded-sm px-2 py-1.5 text-body outline-none transition-colors duration-fast",
+                "data-[selected=true]:bg-accent data-[selected=true]:text-accent-foreground"
+              ),
+              children: /* @__PURE__ */ jsxs5("span", { className: "flex min-w-0 flex-col", children: [
+                /* @__PURE__ */ jsx7("span", { className: "truncate", children: item.label }),
+                item.detail ? /* @__PURE__ */ jsx7("span", { className: "truncate text-meta text-muted-foreground", children: item.detail }) : null
+              ] })
+            },
+            `${item.label}-${String(index)}`
+          );
+        })
+      }
+    );
+  }
+);
+
+// src/markdown-editor/completions/completions-widget.tsx
+import { jsx as jsx8 } from "react/jsx-runtime";
+var ID_PREFIX2 = "brand-completions";
+function createCompletionWidget() {
+  function CompletionWidget() {
+    const { view } = useWidgetViewContext2();
+    const wrapperRef = useRef3(null);
+    const state = completionsPluginKey.getState(view.state);
+    const items = state?.items ?? [];
+    const activeIndex = state ? Math.min(state.index, Math.max(0, items.length - 1)) : 0;
+    const activeId = items.length > 0 ? completionOptionId(ID_PREFIX2, activeIndex) : void 0;
+    useLayoutEffect2(() => {
+      const dom = view.dom;
+      const listEl = wrapperRef.current?.querySelector('[role="listbox"]');
+      if (listEl && !listEl.id) listEl.id = `${ID_PREFIX2}-listbox`;
+      dom.setAttribute("aria-expanded", "true");
+      if (listEl) dom.setAttribute("aria-controls", listEl.id);
+      if (activeId) dom.setAttribute("aria-activedescendant", activeId);
+      else dom.removeAttribute("aria-activedescendant");
+      return () => {
+        dom.removeAttribute("aria-expanded");
+        dom.removeAttribute("aria-controls");
+        dom.removeAttribute("aria-activedescendant");
+      };
+    }, [view, activeId]);
+    const onSelect = (index) => {
+      if (!state) return;
+      const item = items[index];
+      if (item) insertCompletionItem(view, state, item);
+    };
+    return /* @__PURE__ */ jsx8(
+      "span",
+      {
+        ref: wrapperRef,
+        contentEditable: false,
+        className: "brand-completions-anchor relative inline-block h-0 w-0 align-baseline",
+        children: /* @__PURE__ */ jsx8("span", { className: "absolute left-0 top-1 z-50 block", children: /* @__PURE__ */ jsx8(
+          CompletionMenu,
+          {
+            items,
+            activeIndex,
+            onSelect,
+            idPrefix: ID_PREFIX2
+          }
+        ) })
+      }
+    );
+  }
+  return CompletionWidget;
+}
+
+// src/markdown-editor/completions/index.ts
+function completionsViewPlugins(widgetFactory, getProviders) {
+  const widgetComponent = createCompletionWidget();
+  return [completionsProsePlugin({ widgetFactory, widgetComponent, getProviders })];
+}
+
+// src/markdown-editor/directive-views.tsx
+import {
+  Alert,
+  AlertDescription,
+  Card,
+  CardContent,
+  CardHeader,
+  CardTitle,
+  ContextMenu as ContextMenu2,
+  ContextMenuContent as ContextMenuContent2,
+  ContextMenuItem as ContextMenuItem2,
+  ContextMenuRadioGroup,
+  ContextMenuRadioItem,
+  ContextMenuSub,
+  ContextMenuSubContent,
+  ContextMenuSubTrigger,
+  ContextMenuTrigger as ContextMenuTrigger2,
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuRadioGroup,
+  DropdownMenuRadioItem,
+  DropdownMenuSub,
+  DropdownMenuSubContent,
+  DropdownMenuSubTrigger,
+  DropdownMenuTrigger
+} from "@elabs-ai/components-ui";
+import { cn as cn6 } from "@elabs-ai/components-ui/lib/cn";
+import { editorViewCtx as editorViewCtx2, parserCtx as parserCtx2, serializerCtx } from "@milkdown/kit/core";
+import { $view } from "@milkdown/kit/utils";
+import { useNodeViewContext } from "@prosemirror-adapter/react";
+import {
+  ArrowLeftRight,
+  FileText,
+  Grid3x3 as Grid3x32,
+  LayoutGrid,
+  MoreHorizontal,
+  Pencil,
+  Repeat2 as Repeat23
+} from "lucide-react";
+import { useContext as useContext4, useEffect as useEffect4, useRef as useRef6 } from "react";
+
+// src/markdown-editor/milkdown-react/editor.tsx
+import { useMemo as useMemo2, useRef as useRef5, useState as useState3 } from "react";
+
+// src/markdown-editor/milkdown-react/use-get-editor.ts
+import { createContext as createContext2, useContext, useEffect as useEffect3, useRef as useRef4 } from "react";
+var editorInfoContext = createContext2({});
+function useGetEditor() {
+  const {
+    dom,
+    editor: editorRef,
+    setLoading,
+    editorFactory: getEditor
+  } = useContext(editorInfoContext);
+  const domRef = useRef4(null);
+  useEffect3(() => {
+    const div = domRef.current;
+    if (!getEditor) return;
+    if (!div) return;
+    dom.current = div;
+    const editor2 = getEditor(div);
+    if (!editor2) return;
+    setLoading(true);
+    editor2.create().then((editor3) => {
+      editorRef.current = editor3;
+    }).finally(() => {
+      setLoading(false);
+    }).catch(console.error);
+    return () => {
+      editor2.destroy().catch(console.error);
+    };
+  }, [dom, editorRef, getEditor, setLoading]);
+  return domRef;
+}
+
+// src/markdown-editor/milkdown-react/editor.tsx
+import { jsx as jsx9 } from "react/jsx-runtime";
+var Milkdown = () => {
+  const domRef = useGetEditor();
+  return /* @__PURE__ */ jsx9("div", { "data-milkdown-root": true, ref: domRef });
+};
+var MilkdownProvider = ({ children }) => {
+  const dom = useRef5(void 0);
+  const [editorFactory, setEditorFactory] = useState3(void 0);
+  const editor2 = useRef5(void 0);
+  const [loading, setLoading] = useState3(true);
+  const editorInfoCtx = useMemo2(
+    () => ({ loading, dom, editor: editor2, setLoading, editorFactory, setEditorFactory }),
+    [loading, editorFactory]
+  );
+  return /* @__PURE__ */ jsx9(editorInfoContext.Provider, { value: editorInfoCtx, children });
+};
+
+// src/markdown-editor/milkdown-react/use-editor.ts
+import { useCallback, useContext as useContext2, useLayoutEffect as useLayoutEffect3 } from "react";
+function useEditor(getEditor, deps = []) {
+  const editorInfo = useContext2(editorInfoContext);
+  const factory = useCallback(getEditor, deps);
+  useLayoutEffect3(() => {
+    editorInfo.setEditorFactory(() => factory);
+  }, [editorInfo, factory]);
+  return {
+    loading: editorInfo.loading,
+    get: () => editorInfo.editor.current
+  };
+}
+
+// src/markdown-editor/milkdown-react/use-instance.ts
+import { useCallback as useCallback2, useContext as useContext3 } from "react";
+function useInstance() {
+  const editorInfo = useContext3(editorInfoContext);
+  const getInstance = useCallback2(() => {
+    return editorInfo.editor.current;
+  }, [editorInfo.editor]);
+  return [editorInfo.loading, getInstance];
+}
+
+// src/markdown-editor/directive-views.tsx
+import { Fragment as Fragment2, jsx as jsx10, jsxs as jsxs6 } from "react/jsx-runtime";
+var CALLOUT_VARIANT = {
+  info: "info",
+  note: "info",
+  tip: "success",
+  success: "success",
+  warning: "warning",
+  caution: "warning",
+  danger: "destructive",
+  error: "destructive",
+  destructive: "destructive"
+};
+function capitalize(s) {
+  return s ? s.charAt(0).toUpperCase() + s.slice(1) : s;
+}
+function useDirectiveAttrs() {
+  const { node, setAttrs } = useNodeViewContext();
+  const name = String(node.attrs.name);
+  const attributes = node.attrs.attributes ?? {};
+  const update = (key, value) => {
+    const next = { ...attributes };
+    if (value === "") delete next[key];
+    else next[key] = value;
+    setAttrs({ attributes: next });
+  };
+  return { name, attributes, update };
+}
+function InlineEdit({ value, onCommit, ariaLabel, placeholder, className }) {
+  const ref = useRef6(null);
+  useEffect4(() => {
+    const el = ref.current;
+    if (!el) return;
+    if (el === el.ownerDocument.activeElement) return;
+    if (el.textContent !== value) el.textContent = value;
+  }, [value]);
+  const commit = () => {
+    const next = (ref.current?.textContent ?? "").trim();
+    if (next !== value) onCommit(next);
+  };
+  const onKeyDown = (e) => {
+    if (e.key === "Enter") {
+      e.preventDefault();
+      e.currentTarget.blur();
+    } else if (e.key === "Escape") {
+      e.preventDefault();
+      if (ref.current) ref.current.textContent = value;
+      e.currentTarget.blur();
+    }
+  };
+  return /* @__PURE__ */ jsx10(
+    "span",
+    {
+      ref,
+      role: "textbox",
+      "aria-label": ariaLabel,
+      "aria-multiline": false,
+      "data-directive-chrome": "",
+      "data-placeholder": placeholder,
+      contentEditable: true,
+      suppressContentEditableWarning: true,
+      tabIndex: 0,
+      spellCheck: false,
+      onBlur: commit,
+      onKeyDown,
+      className: cn6(
+        "brand-inline-edit rounded-sm outline-none focus-visible:ring-2 focus-visible:ring-ring",
+        className
+      )
+    }
+  );
+}
+function ContainerDirectiveView() {
+  const { contentRef } = useNodeViewContext();
+  const { name, attributes, update } = useDirectiveAttrs();
+  const body = /* @__PURE__ */ jsx10("div", { className: "brand-directive__body", ref: contentRef });
+  if (name === "card") {
+    return /* @__PURE__ */ jsxs6(Card, { className: "brand-directive brand-directive--card", "data-brand-directive": "card", children: [
+      /* @__PURE__ */ jsx10(CardHeader, { className: "pb-3", children: /* @__PURE__ */ jsx10(CardTitle, { children: /* @__PURE__ */ jsx10(
+        InlineEdit,
+        {
+          ariaLabel: "Card title",
+          placeholder: "Card title",
+          value: attributes.title ?? "",
+          onCommit: (v) => update("title", v)
+        }
+      ) }) }),
+      /* @__PURE__ */ jsx10(CardContent, { children: body })
+    ] });
+  }
+  if (name === "callout") {
+    const variant = CALLOUT_VARIANT[attributes.type ?? ""] ?? "default";
+    return /* @__PURE__ */ jsxs6(
+      Alert,
+      {
+        variant,
+        className: "brand-directive brand-directive--callout",
+        "data-brand-directive": "callout",
+        children: [
+          /* @__PURE__ */ jsx10("div", { className: "mb-1 font-medium leading-none tracking-tight", children: /* @__PURE__ */ jsx10(
+            InlineEdit,
+            {
+              ariaLabel: "Callout title",
+              placeholder: capitalize(attributes.type ?? "note"),
+              value: attributes.title ?? "",
+              onCommit: (v) => update("title", v)
+            }
+          ) }),
+          /* @__PURE__ */ jsx10(AlertDescription, { children: body })
+        ]
+      }
+    );
+  }
+  if (name === "timeline") {
+    return /* @__PURE__ */ jsx10("div", { className: "brand-directive brand-directive--timeline", "data-brand-directive": "timeline", children: body });
+  }
+  if (name === "iterate" || name === "pivot") {
+    return /* @__PURE__ */ jsx10(IterationDirectiveView, {});
+  }
+  return /* @__PURE__ */ jsxs6(
+    Alert,
+    {
+      role: "note",
+      variant: "destructive",
+      className: "brand-directive brand-directive--unknown",
+      "data-brand-directive": name,
+      children: [
+        /* @__PURE__ */ jsxs6("div", { className: "mb-1 font-medium leading-none tracking-tight", children: [
+          "Unknown block: ",
+          name
+        ] }),
+        /* @__PURE__ */ jsx10(AlertDescription, { children: body })
+      ]
+    }
+  );
+}
+function readBodyMarkdown(getInstance, node) {
+  try {
+    const editor2 = getInstance();
+    if (!editor2) return node.textContent;
+    return editor2.action((ctx2) => {
+      const serialize = ctx2.get(
+        serializerCtx
+      );
+      const doc = node.type.schema.topNodeType.create(null, node.content);
+      return serialize(doc);
+    }).trim();
+  } catch {
+    return node.textContent;
+  }
+}
+function writeBodyMarkdown(getInstance, getPos, template) {
+  try {
+    const editor2 = getInstance();
+    const pos = getPos();
+    if (!editor2 || pos == null) return;
+    editor2.action((ctx2) => {
+      const parse = ctx2.get(
+        parserCtx2
+      );
+      const parsed = parse(template);
+      if (!parsed) return;
+      const view = ctx2.get(editorViewCtx2);
+      const node = view.state.doc.nodeAt(pos);
+      if (!node) return;
+      const start = pos + 1;
+      const end = start + node.content.size;
+      const tr = view.state.tr.replaceWith(start, end, parsed.content);
+      view.dispatch(tr);
+    });
+  } catch {
+  }
+}
+function mergeAttrsOmittingEmpty(attrs, next) {
+  const merged = { ...attrs };
+  for (const [key, value] of Object.entries(next)) {
+    if (value === "") delete merged[key];
+    else merged[key] = value;
+  }
+  return merged;
+}
+function replaceNodeWithMarkdown(getInstance, getPos, markdown) {
+  if (!markdown.trim()) return;
+  try {
+    const editor2 = getInstance();
+    const pos = getPos();
+    if (!editor2 || pos == null) return;
+    editor2.action((ctx2) => {
+      const parse = ctx2.get(
+        parserCtx2
+      );
+      const parsed = parse(markdown);
+      if (!parsed) return;
+      const view = ctx2.get(editorViewCtx2);
+      const node = view.state.doc.nodeAt(pos);
+      if (!node) return;
+      const tr = view.state.tr.replaceWith(pos, pos + node.nodeSize, parsed.content);
+      view.dispatch(tr);
+    });
+  } catch {
+  }
+}
+function IterationMenuItems({
+  kind,
+  entries
+}) {
+  const isDropdown = kind === "dropdown";
+  const Item = isDropdown ? DropdownMenuItem : ContextMenuItem2;
+  const Sub = isDropdown ? DropdownMenuSub : ContextMenuSub;
+  const SubTrigger = isDropdown ? DropdownMenuSubTrigger : ContextMenuSubTrigger;
+  const SubContent = isDropdown ? DropdownMenuSubContent : ContextMenuSubContent;
+  const RadioGroup = isDropdown ? DropdownMenuRadioGroup : ContextMenuRadioGroup;
+  const RadioItem = isDropdown ? DropdownMenuRadioItem : ContextMenuRadioItem;
+  return /* @__PURE__ */ jsx10(Fragment2, { children: entries.map((entry) => {
+    if (entry.type === "layout") {
+      return /* @__PURE__ */ jsxs6(Sub, { children: [
+        /* @__PURE__ */ jsxs6(SubTrigger, { className: "gap-2", children: [
+          entry.icon,
+          entry.label
+        ] }),
+        /* @__PURE__ */ jsx10(SubContent, { children: /* @__PURE__ */ jsx10(
+          RadioGroup,
+          {
+            value: entry.value,
+            onValueChange: (next) => entry.onChange(next),
+            children: entry.options.map((option) => /* @__PURE__ */ jsx10(RadioItem, { value: option, className: "capitalize", children: option }, option))
+          }
+        ) })
+      ] }, entry.id);
+    }
+    return /* @__PURE__ */ jsxs6(Item, { onSelect: entry.onSelect, disabled: entry.disabled, children: [
+      entry.icon,
+      entry.label
+    ] }, entry.id);
+  }) });
+}
+function IterationDirectiveView() {
+  const { contentRef, node, getPos, setAttrs } = useNodeViewContext();
+  const { name, attributes } = useDirectiveAttrs();
+  const [, getInstance] = useInstance();
+  const onEdit = useContext4(IterationEditContext);
+  const isPivot = name === "pivot";
+  const kind = isPivot ? "pivot" : "iterate";
+  const Icon = isPivot ? Grid3x32 : Repeat23;
+  const requestEdit = () => {
+    onEdit?.({
+      kind,
+      template: readBodyMarkdown(getInstance, node),
+      // A5: hand the current attributes (value lists, bind name, layout) to the
+      // handler so the GUIDED builder can reopen with its data — and a writer that
+      // round-trips BOTH the attributes and the body, not just the template.
+      attributes: { ...attributes },
+      onSave: (template) => writeBodyMarkdown(getInstance, getPos, template),
+      // MERGE the guided builder's write-back into the EXISTING attributes rather
+      // than replacing the whole record — `directivePartsFromValue` only knows
+      // about `as`/`layout`/`values`/`rows`/`cols`, so a naive
+      // `setAttrs({ attributes: nextAttrs })` would silently drop every other
+      // attribute the directive carries (e.g. a consumer's `source`/`region`
+      // reference — `containerDirectiveSchema.attrs.attributes` is a free-form
+      // record, and those keys are load-bearing for the consumer's `evaluate`).
+      // Mirrors the `transpose()` fix below.
+      onSaveData: ({ attributes: nextAttrs, template }) => {
+        setAttrs({
+          attributes: mergeAttrsOmittingEmpty(attributes, nextAttrs)
+        });
+        writeBodyMarkdown(getInstance, getPos, template);
+      },
+      onSetAttributes: (nextAttrs) => setAttrs({ attributes: nextAttrs }),
+      onReplaceWithMarkdown: (markdown) => replaceNodeWithMarkdown(getInstance, getPos, markdown)
+    });
+  };
+  const setLayout = (layout) => {
+    setAttrs({ attributes: { ...attributes, layout } });
+  };
+  const transpose = () => {
+    const seed = builderValueFromParts(kind, attributes, "");
+    const { attributes: transposed } = directivePartsFromValue(transposeIterationValue(seed));
+    setAttrs({
+      attributes: mergeAttrsOmittingEmpty(attributes, {
+        rows: transposed.rows ?? "",
+        cols: transposed.cols ?? ""
+      })
+    });
+  };
+  const hasEmbeddedData = evaluateEmbedded({
+    kind,
+    layout: attributes.layout || ITERATION_LAYOUTS[kind][0],
+    template: "",
+    as: attributes.as || "item",
+    attributes
+  }).cells.length > 0;
+  const disabledHint = "\u2014 needs embedded values";
+  const convertToStatic = () => {
+    const template = readBodyMarkdown(getInstance, node);
+    const value = builderValueFromParts(kind, attributes, template);
+    replaceNodeWithMarkdown(getInstance, getPos, staticMarkdownFromValue(value));
+  };
+  const menuEntries = [
+    {
+      type: "item",
+      id: "edit",
+      label: "Edit iteration\u2026",
+      icon: /* @__PURE__ */ jsx10(Pencil, { className: "size-4", "aria-hidden": "true" }),
+      onSelect: requestEdit
+    },
+    {
+      type: "layout",
+      id: "layout",
+      label: "Change layout",
+      icon: /* @__PURE__ */ jsx10(LayoutGrid, { className: "size-4", "aria-hidden": "true" }),
+      value: attributes.layout || ITERATION_LAYOUTS[kind][0],
+      options: ITERATION_LAYOUTS[kind],
+      onChange: setLayout
+    },
+    ...isPivot ? [
+      {
+        type: "item",
+        id: "transpose",
+        label: hasEmbeddedData ? "Transpose" : `Transpose ${disabledHint}`,
+        icon: /* @__PURE__ */ jsx10(ArrowLeftRight, { className: "size-4", "aria-hidden": "true" }),
+        onSelect: transpose,
+        disabled: !hasEmbeddedData
+      }
+    ] : [],
+    {
+      type: "item",
+      id: "convert-to-static",
+      label: hasEmbeddedData ? "Convert to static" : `Convert to static ${disabledHint}`,
+      icon: /* @__PURE__ */ jsx10(FileText, { className: "size-4", "aria-hidden": "true" }),
+      onSelect: convertToStatic,
+      disabled: !hasEmbeddedData
+    }
+  ];
+  const header = /* @__PURE__ */ jsxs6("div", { className: "mb-1.5 flex items-center gap-1.5 text-meta font-medium text-info-text", children: [
+    /* @__PURE__ */ jsx10(Icon, { className: "size-3.5 shrink-0", "aria-hidden": "true" }),
+    /* @__PURE__ */ jsx10("span", { children: isPivot ? "Pivot" : "Iterate" }),
+    !isPivot && attributes.as ? /* @__PURE__ */ jsxs6("span", { className: "font-normal text-muted-foreground", children: [
+      "\xB7 per ",
+      attributes.as
+    ] }) : null,
+    /* @__PURE__ */ jsx10("span", { className: "font-normal text-muted-foreground", children: "\u2014 template" }),
+    onEdit ? /* @__PURE__ */ jsxs6(DropdownMenu, { children: [
+      /* @__PURE__ */ jsx10(DropdownMenuTrigger, { asChild: true, children: /* @__PURE__ */ jsx10(
+        "button",
+        {
+          type: "button",
+          "data-directive-chrome": "",
+          "aria-label": "Iteration actions",
+          title: "Iteration actions\u2026",
+          className: "ms-auto inline-flex size-5 items-center justify-center rounded-sm text-muted-foreground hover:bg-accent hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
+          children: /* @__PURE__ */ jsx10(MoreHorizontal, { className: "size-4", "aria-hidden": "true" })
+        }
+      ) }),
+      /* @__PURE__ */ jsx10(DropdownMenuContent, { align: "end", children: /* @__PURE__ */ jsx10(IterationMenuItems, { kind: "dropdown", entries: menuEntries }) })
+    ] }) : null
+  ] });
+  const body = (
+    // The editable template body (inline ProseMirror content).
+    /* @__PURE__ */ jsx10("div", { className: "brand-directive__body", ref: contentRef })
+  );
+  if (!onEdit) {
+    return /* @__PURE__ */ jsxs6(
+      "div",
+      {
+        className: "brand-directive brand-directive--iterate border-s-2 border-s-info ps-3",
+        "data-brand-directive": name,
+        children: [
+          header,
+          body
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs6(ContextMenu2, { children: [
+    /* @__PURE__ */ jsxs6(
+      "div",
+      {
+        className: "brand-directive brand-directive--iterate border-s-2 border-s-info ps-3",
+        "data-brand-directive": name,
+        children: [
+          /* @__PURE__ */ jsx10(ContextMenuTrigger2, { asChild: true, children: header }),
+          body
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx10(ContextMenuContent2, { children: /* @__PURE__ */ jsx10(IterationMenuItems, { kind: "context", entries: menuEntries }) })
+  ] });
+}
+function LeafDirectiveView() {
+  const { name, attributes, update } = useDirectiveAttrs();
+  if (name !== "metric") {
+    return /* @__PURE__ */ jsxs6(
+      "div",
+      {
+        className: "brand-directive brand-directive--leaf brand-directive--unknown rounded-md border border-destructive/40 bg-surface-muted p-3 text-sm text-muted-foreground",
+        "data-brand-leaf": name,
+        children: [
+          "Unknown inline block: ",
+          /* @__PURE__ */ jsxs6("code", { children: [
+            "::",
+            name
+          ] })
+        ]
+      }
+    );
+  }
+  const delta = attributes.delta;
+  return /* @__PURE__ */ jsx10(
+    MetricBlock,
+    {
+      className: "brand-directive brand-directive--leaf brand-directive--metric",
+      "data-brand-leaf": "metric",
+      label: /* @__PURE__ */ jsx10(
+        InlineEdit,
+        {
+          ariaLabel: "Metric label",
+          placeholder: "Label",
+          value: attributes.label ?? "",
+          onCommit: (v) => update("label", v)
+        }
+      ),
+      value: /* @__PURE__ */ jsx10(
+        InlineEdit,
+        {
+          ariaLabel: "Metric value",
+          placeholder: "0",
+          value: attributes.value ?? "",
+          onCommit: (v) => update("value", v),
+          className: "min-w-[1ch]"
+        }
+      ),
+      description: attributes.description,
+      delta,
+      deltaDirection: delta?.startsWith("+") ? "up" : delta?.startsWith("-") ? "down" : "neutral"
+    }
+  );
+}
+function directiveStopEvent(event) {
+  let node = event.target;
+  while (node instanceof HTMLElement) {
+    if (node.hasAttribute("data-directive-chrome")) return true;
+    if (node.hasAttribute("data-node-view-root")) return false;
+    node = node.parentElement;
+  }
+  return false;
+}
+function directiveViewPlugins(nodeViewFactory) {
+  return [
+    $view(
+      containerDirectiveSchema.node,
+      () => nodeViewFactory({
+        component: ContainerDirectiveView,
+        as: "div",
+        contentAs: "div",
+        stopEvent: directiveStopEvent
+      })
+    ),
+    $view(
+      leafDirectiveSchema.node,
+      () => nodeViewFactory({
+        component: LeafDirectiveView,
+        as: "div",
+        stopEvent: directiveStopEvent
+      })
+    )
+  ].flat();
+}
+
+// src/markdown-editor/exit-keymap.ts
+import { $prose as $prose5 } from "@milkdown/kit/utils";
+import { Plugin as Plugin5, TextSelection as TextSelection2 } from "@milkdown/kit/prose/state";
+var exitCodeBlock = (state, dispatch) => {
+  const { selection } = state;
+  if (!selection.empty) return false;
+  const { $head } = selection;
+  if (!$head.parent.type.spec.code) return false;
+  const paragraph = state.schema.nodes.paragraph;
+  if (!paragraph) return false;
+  const after = $head.after($head.depth);
+  if (dispatch) {
+    const nodeAfter = state.doc.resolve(after).nodeAfter;
+    let tr = state.tr;
+    if (nodeAfter && nodeAfter.isTextblock) {
+      tr = tr.setSelection(TextSelection2.create(tr.doc, after + 1));
+    } else {
+      const para = paragraph.createAndFill();
+      if (!para) return false;
+      tr = tr.insert(after, para);
+      tr = tr.setSelection(TextSelection2.create(tr.doc, after + 1));
+    }
+    dispatch(tr.scrollIntoView());
+  }
+  return true;
+};
+function exitKeymapPlugins() {
+  return [
+    $prose5(
+      () => new Plugin5({
+        props: {
+          handleKeyDown: (view, event) => {
+            const isTab = event.key === "Tab" && !event.shiftKey;
+            const isModEnter = event.key === "Enter" && (event.metaKey || event.ctrlKey);
+            if (!isTab && !isModEnter) return false;
+            const handled = exitCodeBlock(view.state, view.dispatch);
+            if (handled) event.preventDefault();
+            return handled;
+          }
+        }
+      })
+    )
+  ];
+}
+
+// src/markdown-editor/paste-embed.ts
+import { $prose as $prose6 } from "@milkdown/kit/utils";
+import { Plugin as Plugin6, PluginKey as PluginKey5 } from "@milkdown/kit/prose/state";
+import { Decoration as Decoration2, DecorationSet as DecorationSet4 } from "@milkdown/kit/prose/view";
+import { toast } from "@elabs-ai/components-ui";
+function uniqueId() {
+  return `embed-${Math.random().toString(36).slice(2)}`;
+}
+var embedPluginKey = new PluginKey5("brand-embed");
+function makePlaceholderChip(filename) {
+  const chip = document.createElement("span");
+  chip.setAttribute("role", "status");
+  chip.setAttribute("aria-live", "polite");
+  chip.setAttribute("aria-label", `Uploading ${filename}`);
+  chip.setAttribute("title", `Uploading ${filename}\u2026`);
+  chip.className = "inline-flex items-center gap-1 rounded px-2 py-0.5 text-caption bg-muted text-muted-foreground border border-border select-none transition-opacity duration-normal ease-standard motion-reduce:transition-none";
+  const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+  svg.setAttribute("viewBox", "0 0 24 24");
+  svg.setAttribute("fill", "none");
+  svg.setAttribute("aria-hidden", "true");
+  svg.style.cssText = "width:0.85em;height:0.85em;animation:spin 1s linear infinite;flex-shrink:0;";
+  const circle = document.createElementNS("http://www.w3.org/2000/svg", "circle");
+  circle.setAttribute("cx", "12");
+  circle.setAttribute("cy", "12");
+  circle.setAttribute("r", "9");
+  circle.setAttribute("stroke", "currentColor");
+  circle.setAttribute("stroke-width", "2.5");
+  circle.setAttribute("stroke-dasharray", "56.5");
+  circle.setAttribute("stroke-dashoffset", "42");
+  circle.setAttribute("stroke-linecap", "round");
+  svg.appendChild(circle);
+  chip.appendChild(svg);
+  if (!chip.ownerDocument.head.querySelector("#embed-spin-keyframe")) {
+    const style = chip.ownerDocument.createElement("style");
+    style.id = "embed-spin-keyframe";
+    style.textContent = "@keyframes spin{to{transform:rotate(360deg)}}";
+    chip.ownerDocument.head.appendChild(style);
+  }
+  const label = document.createElement("span");
+  label.textContent = `${filename.length > 24 ? filename.slice(0, 22) + "\u2026" : filename} Uploading\u2026`;
+  chip.appendChild(label);
+  return chip;
+}
+function makeErrorChip(message) {
+  const chip = document.createElement("span");
+  chip.setAttribute("role", "alert");
+  chip.setAttribute("aria-live", "assertive");
+  chip.setAttribute("title", message);
+  chip.className = "inline-flex items-center gap-1 rounded px-2 py-0.5 text-caption bg-destructive/10 text-destructive border border-destructive/30 select-none";
+  const label = document.createElement("span");
+  label.textContent = `\u26A0 Upload failed`;
+  chip.appendChild(label);
+  return chip;
+}
+function embedAsset(view, file, pos, onEmbedAsset, onError) {
+  const id = uniqueId();
+  const addMeta = { type: "add", id, pos, filename: file.name };
+  view.dispatch(view.state.tr.setMeta(embedPluginKey, addMeta));
+  onEmbedAsset(file).then(
+    (path) => {
+      const pluginState = embedPluginKey.getState(view.state);
+      const deco = pluginState?.byId.get(id);
+      const removeMeta = { type: "remove", id };
+      const tr = view.state.tr.setMeta(embedPluginKey, removeMeta);
+      if (deco) {
+        const decoPos = deco.from;
+        const imageNode = view.state.schema.nodes.image?.create({
+          src: path,
+          alt: file.name.replace(/\.[^.]+$/, ""),
+          title: null
+        });
+        if (imageNode) {
+          const insertTr = view.state.tr.insert(decoPos, imageNode);
+          view.dispatch(insertTr);
+          const removeTr = view.state.tr.setMeta(embedPluginKey, removeMeta);
+          view.dispatch(removeTr);
+          return;
+        }
+      }
+      view.dispatch(tr);
+    },
+    (err) => {
+      const pluginState = embedPluginKey.getState(view.state);
+      const deco = pluginState?.byId.get(id);
+      const errPos = deco ? deco.from : pos;
+      const message = err instanceof Error ? err.message : "Upload failed";
+      const errorMeta = { type: "error", id, pos: errPos, message };
+      view.dispatch(view.state.tr.setMeta(embedPluginKey, errorMeta));
+      toast.error(`Upload failed: ${message}`);
+      onError?.(message);
+      setTimeout(() => {
+        if (view.isDestroyed) return;
+        const clearMeta = { type: "clear-error", id };
+        view.dispatch(view.state.tr.setMeta(embedPluginKey, clearMeta));
+      }, 4e3);
+    }
+  );
+}
+function imageFiles(list) {
+  if (!list) return [];
+  const files = [];
+  for (let i = 0; i < list.length; i++) {
+    const f = list[i];
+    if (f && f.type.startsWith("image/")) files.push(f);
+  }
+  return files;
+}
+function pasteEmbedPlugin(onEmbedAsset) {
+  return $prose6(() => {
+    return new Plugin6({
+      key: embedPluginKey,
+      state: {
+        init: () => ({
+          decos: DecorationSet4.empty,
+          byId: /* @__PURE__ */ new Map(),
+          errorIds: /* @__PURE__ */ new Set()
+        }),
+        apply: (tr, prev, _oldState, newState) => {
+          let decos = prev.decos.map(tr.mapping, tr.doc);
+          const byId = new Map(prev.byId);
+          const errorIds = new Set(prev.errorIds);
+          for (const [id, oldDeco] of prev.byId.entries()) {
+            const key = oldDeco.spec.key;
+            if (key) {
+              const found = decos.find(void 0, void 0, (spec) => spec.key === key);
+              if (found.length > 0 && found[0]) {
+                byId.set(id, found[0]);
+              } else {
+                byId.delete(id);
+              }
+            }
+          }
+          const meta = tr.getMeta(embedPluginKey);
+          if (!meta) return { decos, byId, errorIds };
+          switch (meta.type) {
+            case "add": {
+              const chip = makePlaceholderChip(meta.filename);
+              const deco = Decoration2.widget(meta.pos, chip, {
+                key: `embed-placeholder:${meta.id}`,
+                side: -1
+              });
+              decos = decos.add(newState.doc, [deco]);
+              byId.set(meta.id, deco);
+              break;
+            }
+            case "remove": {
+              const key = `embed-placeholder:${meta.id}`;
+              const toRemove = decos.find(void 0, void 0, (spec) => spec.key === key);
+              if (toRemove.length > 0) {
+                decos = decos.remove(toRemove);
+              }
+              byId.delete(meta.id);
+              errorIds.delete(meta.id);
+              break;
+            }
+            case "error": {
+              const placeholderKey = `embed-placeholder:${meta.id}`;
+              const placeholders = decos.find(
+                void 0,
+                void 0,
+                (spec) => spec.key === placeholderKey
+              );
+              if (placeholders.length > 0) {
+                decos = decos.remove(placeholders);
+              }
+              byId.delete(meta.id);
+              const chip = makeErrorChip(meta.message);
+              const errorKey = `embed-error:${meta.id}`;
+              const deco = Decoration2.widget(meta.pos, chip, { key: errorKey, side: 1 });
+              decos = decos.add(newState.doc, [deco]);
+              errorIds.add(meta.id);
+              break;
+            }
+            case "clear-error": {
+              const errorKey = `embed-error:${meta.id}`;
+              const toRemove = decos.find(void 0, void 0, (spec) => spec.key === errorKey);
+              if (toRemove.length > 0) {
+                decos = decos.remove(toRemove);
+              }
+              errorIds.delete(meta.id);
+              break;
+            }
+          }
+          return { decos, byId, errorIds };
+        }
+      },
+      props: {
+        decorations: (state) => embedPluginKey.getState(state)?.decos ?? DecorationSet4.empty,
+        handlePaste: (view, event) => {
+          if (!onEmbedAsset) return false;
+          const files = imageFiles(event.clipboardData?.files);
+          if (files.length === 0) return false;
+          event.preventDefault();
+          const pos = view.state.selection.from;
+          for (const file of files) {
+            embedAsset(view, file, pos, onEmbedAsset);
+          }
+          return true;
+        },
+        handleDrop: (view, event) => {
+          if (!onEmbedAsset) return false;
+          const files = imageFiles(event.dataTransfer?.files);
+          if (files.length === 0) return false;
+          event.preventDefault();
+          const coords = view.posAtCoords({
+            left: event.clientX,
+            top: event.clientY
+          });
+          const pos = coords?.pos ?? view.state.selection.from;
+          for (const file of files) {
+            embedAsset(view, file, pos, onEmbedAsset);
+          }
+          return true;
+        }
+      }
+    });
+  });
+}
+
+// src/markdown-editor/table-view.tsx
+import { commandsCtx } from "@milkdown/kit/core";
+import {
+  addColAfterCommand,
+  addColBeforeCommand,
+  addRowAfterCommand,
+  addRowBeforeCommand,
+  deleteSelectedCellsCommand
+} from "@milkdown/kit/preset/gfm";
+import { Plugin as Plugin7, PluginKey as PluginKey6 } from "@milkdown/kit/prose/state";
+import { $prose as $prose7 } from "@milkdown/kit/utils";
+import { isInTable } from "@milkdown/kit/prose/tables";
+import { cn as cn7 } from "@elabs-ai/components-ui/lib/cn";
+import { usePluginViewContext } from "@prosemirror-adapter/react";
+import { jsx as jsx11, jsxs as jsxs7 } from "react/jsx-runtime";
+var ctxByView = /* @__PURE__ */ new WeakMap();
+function dispatchCommand(view, key) {
+  const ctx2 = ctxByView.get(view);
+  if (!ctx2) return;
+  try {
+    ctx2.get(commandsCtx).call(key);
+  } catch {
+  }
+}
+var tableControlsKey = new PluginKey6("brand-table-controls");
+function ToolbarButton({
+  onClick,
+  ariaLabel,
+  title,
+  children,
+  variant = "default"
+}) {
+  return /* @__PURE__ */ jsx11(
+    "button",
+    {
+      type: "button",
+      "aria-label": ariaLabel,
+      title,
+      onMouseDown: (e) => e.preventDefault(),
+      onClick,
+      className: cn7(
+        "inline-flex h-7 items-center gap-1 rounded px-2 text-caption font-medium",
+        "border border-border-strong",
+        "focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
+        "transition-colors duration-fast ease-standard motion-reduce:transition-none",
+        variant === "destructive" ? "bg-background text-destructive hover:bg-destructive/10" : "bg-background text-foreground hover:bg-surface-muted"
+      ),
+      children
+    }
+  );
+}
+function ToolbarDivider() {
+  return /* @__PURE__ */ jsx11("span", { "aria-hidden": "true", className: "mx-0.5 h-4 w-px bg-border-strong" });
+}
+function TableControlsView() {
+  const { view } = usePluginViewContext();
+  const inTable = isInTable(view.state);
+  const run = (key) => () => dispatchCommand(view, key);
+  if (!inTable) return null;
+  return /* @__PURE__ */ jsxs7(
+    "div",
+    {
+      role: "toolbar",
+      "aria-label": "Table controls",
+      className: cn7(
+        "flex flex-wrap items-center gap-1 px-2 py-1.5",
+        "border-t border-border-strong bg-surface-muted"
+      ),
+      children: [
+        /* @__PURE__ */ jsx11("span", { className: "mr-1 select-none text-caption text-muted-foreground", children: "Row" }),
+        /* @__PURE__ */ jsx11(
+          ToolbarButton,
+          {
+            ariaLabel: "Add row above",
+            title: "Add row above",
+            onClick: run(addRowBeforeCommand.key),
+            children: "\u2191+"
+          }
+        ),
+        /* @__PURE__ */ jsx11(
+          ToolbarButton,
+          {
+            ariaLabel: "Add row below",
+            title: "Add row below",
+            onClick: run(addRowAfterCommand.key),
+            children: "\u2193+"
+          }
+        ),
+        /* @__PURE__ */ jsx11(
+          ToolbarButton,
+          {
+            ariaLabel: "Delete row",
+            title: "Delete row",
+            variant: "destructive",
+            onClick: run(deleteSelectedCellsCommand.key),
+            children: "\xD7row"
+          }
+        ),
+        /* @__PURE__ */ jsx11(ToolbarDivider, {}),
+        /* @__PURE__ */ jsx11("span", { className: "mr-1 select-none text-caption text-muted-foreground", children: "Col" }),
+        /* @__PURE__ */ jsx11(
+          ToolbarButton,
+          {
+            ariaLabel: "Add column left",
+            title: "Add column left",
+            onClick: run(addColBeforeCommand.key),
+            children: "\u2190+"
+          }
+        ),
+        /* @__PURE__ */ jsx11(
+          ToolbarButton,
+          {
+            ariaLabel: "Add column right",
+            title: "Add column right",
+            onClick: run(addColAfterCommand.key),
+            children: "\u2192+"
+          }
+        ),
+        /* @__PURE__ */ jsx11(
+          ToolbarButton,
+          {
+            ariaLabel: "Delete column",
+            title: "Delete column",
+            variant: "destructive",
+            onClick: run(deleteSelectedCellsCommand.key),
+            children: "\xD7col"
+          }
+        )
+      ]
+    }
+  );
+}
+function tableViewPlugins(pluginViewFactory) {
+  return [
+    $prose7((ctx2) => {
+      const makePluginView = pluginViewFactory({ component: TableControlsView });
+      return new Plugin7({
+        key: tableControlsKey,
+        state: {
+          // Track whether the cursor is in a table (bool) as plugin state so
+          // ProseMirror knows when to trigger an `update()` on the plugin view.
+          init: (_cfg, state) => isInTable(state),
+          apply: (_tr, _prev, _old, state) => isInTable(state)
+        },
+        // Bind THIS editor's Ctx to THIS editor's view, so the toolbar's
+        // commands dispatch to the right instance when several editors share
+        // this module (autodocs page, split workspace).
+        view: (editorView) => {
+          ctxByView.set(editorView, ctx2);
+          return makePluginView(editorView);
+        }
+      });
+    })
+  ];
+}
+
+// src/markdown-editor/markdown-editor.tsx
+import { jsx as jsx12 } from "react/jsx-runtime";
+function scrollHeadingBySlug(editor2, slug) {
+  editor2.action((ctx2) => {
+    const view = ctx2.get(editorViewCtx3);
+    const { doc } = view.state;
+    const used = /* @__PURE__ */ new Map();
+    let targetPos = null;
+    doc.forEach((node, offset) => {
+      if (targetPos !== null) return;
+      if (node.type.name === "heading") {
+        const id = uniqueSlug(slugifyHeading(plainText(node.textContent)), used);
+        if (id === slug) targetPos = offset + 1;
+      }
+    });
+    if (targetPos === null) return;
+    try {
+      const resolved = doc.resolve(targetPos);
+      view.dispatch(view.state.tr.setSelection(TextSelection3.near(resolved)).scrollIntoView());
+    } catch {
+    }
+  });
+}
+var MarkdownEditorView = forwardRef6(function MarkdownEditorView2({
+  initialValue,
+  value,
+  onChange,
+  readOnly,
+  ariaLabel,
+  slashMenu,
+  calc,
+  completions,
+  onEmbedAsset
+}, ref) {
+  const onChangeRef = useRef7(onChange);
+  onChangeRef.current = onChange;
+  const lastMarkdown = useRef7(initialValue);
+  const nodeViewFactory = useNodeViewFactory();
+  const widgetViewFactory = useWidgetViewFactory();
+  const pluginViewFactory = usePluginViewFactory();
+  const slashEnabled = slashMenu !== false;
+  const slashConfigRef = useRef7(
+    {}
+  );
+  slashConfigRef.current = typeof slashMenu === "object" ? slashMenu : {};
+  const calcEnabled = calc != null;
+  const calcRef = useRef7(calc);
+  calcRef.current = calc;
+  const completionsEnabled = completions != null;
+  const completionsRef = useRef7(completions);
+  completionsRef.current = completions;
+  const onEmbedAssetRef = useRef7(onEmbedAsset);
+  onEmbedAssetRef.current = onEmbedAsset;
+  const iterationEditHandler = useContext5(IterationEditContext);
+  const iterationEditHandlerRef = useRef7(iterationEditHandler);
+  iterationEditHandlerRef.current = iterationEditHandler;
+  const selectionListeners = useRef7(/* @__PURE__ */ new Set()).current;
+  const serializeSliceRef = useRef7(() => "");
+  useEditor(
+    (root) => {
+      const embedPlugin = pasteEmbedPlugin(
+        onEmbedAssetRef.current ? (file) => onEmbedAssetRef.current(file) : void 0
+      );
+      let editor2 = Editor.make().config((ctx2) => {
+        ctx2.set(rootCtx, root);
+        ctx2.set(defaultValueCtx, lastMarkdown.current);
+        ctx2.update(editorViewOptionsCtx, (prev) => ({
+          ...prev,
+          editable: () => !readOnly,
+          // Name the ProseMirror `role="textbox"` surface so AT announces it.
+          // Spread prev.attributes so we never clobber Milkdown's own view attrs.
+          attributes: { ...prev.attributes, "aria-label": ariaLabel }
+        }));
+        ctx2.get(listenerCtx).markdownUpdated((_, markdown) => {
+          lastMarkdown.current = markdown;
+          onChangeRef.current?.(markdown);
+        });
+      }).use(commonmark).use(gfm).use(tableViewPlugins(pluginViewFactory)).use(exitKeymapPlugins()).use(history).use(listener).use(directivePlugins).use(directiveViewPlugins(nodeViewFactory)).use(embedPlugin).use(
+        selectionWatchPlugin(
+          () => selectionListeners,
+          () => serializeSliceRef.current
+        )
+      );
+      if (slashEnabled) {
+        editor2 = editor2.use(
+          brandSlashViewPlugins(widgetViewFactory, {
+            ...slashConfigRef.current,
+            getIterationEditHandler: () => iterationEditHandlerRef.current
+          })
+        );
+      }
+      if (calcEnabled) {
+        editor2 = editor2.use(calcProsePlugins(() => calcRef.current));
+      }
+      if (completionsEnabled) {
+        editor2 = editor2.use(
+          completionsViewPlugins(widgetViewFactory, () => completionsRef.current)
+        );
+      }
+      return editor2;
+    },
+    [readOnly, ariaLabel, slashEnabled, calcEnabled, completionsEnabled]
+  );
+  const [loading, getInstance] = useInstance();
+  useEffect5(() => {
+    if (loading || value === void 0) return;
+    if (value === lastMarkdown.current) return;
+    const editor2 = getInstance();
+    if (!editor2) return;
+    lastMarkdown.current = value;
+    editor2.action(replaceAll(value));
+  }, [loading, value, getInstance]);
+  useImperativeHandle2(
+    ref,
+    () => {
+      const serializeSlice = (view) => {
+        const editor2 = getInstance();
+        if (!editor2) return "";
+        const { selection } = view.state;
+        if (selection.empty) return "";
+        try {
+          return editor2.action((ctx2) => {
+            const serialize = ctx2.get(serializerCtx2);
+            const doc = selection.content().content;
+            const wrapper = view.state.doc.type.schema.topNodeType.create(null, doc);
+            return serialize(wrapper);
+          }).trim();
+        } catch {
+          return view.state.doc.textBetween(selection.from, selection.to, "\n");
+        }
+      };
+      serializeSliceRef.current = serializeSlice;
+      const parseAndReplace = (view, md) => {
+        const editor2 = getInstance();
+        if (!editor2) return;
+        try {
+          editor2.action((ctx2) => {
+            const parse = ctx2.get(parserCtx3);
+            const parsed = parse(md);
+            if (!parsed) {
+              view.dispatch(view.state.tr.insertText(md));
+              return;
+            }
+            const tr = view.state.tr.replaceSelectionWith(parsed);
+            view.dispatch(tr);
+          });
+        } catch {
+          try {
+            view.dispatch(view.state.tr.insertText(md));
+          } catch {
+          }
+        }
+      };
+      const getView = () => {
+        const editor2 = getInstance();
+        if (!editor2) return null;
+        try {
+          return editor2.action((ctx2) => ctx2.get(editorViewCtx3));
+        } catch {
+          return null;
+        }
+      };
+      const access = proseMirrorContentAccess({
+        getView,
+        getText: () => getInstance()?.action(getMarkdown()) ?? lastMarkdown.current,
+        serializeSlice,
+        parseAndReplace,
+        listeners: selectionListeners
+      });
+      return {
+        // EditorContentAccess methods (via proseMirrorContentAccess).
+        getText: access.getText,
+        getSelection: access.getSelection,
+        replaceSelection: access.replaceSelection,
+        insertAtCursor: access.insertAtCursor,
+        focus: access.focus,
+        onSelectionChange: access.onSelectionChange,
+        // Markdown-specific methods.
+        getMarkdown: () => getInstance()?.action(getMarkdown()) ?? lastMarkdown.current,
+        serialized: () => getInstance()?.action(getMarkdown()) ?? null,
+        scrollToHeading: (slug) => {
+          const editor2 = getInstance();
+          if (editor2) scrollHeadingBySlug(editor2, slug);
+        },
+        revealLine: (line, _opts) => {
+          const editor2 = getInstance();
+          if (!editor2) return;
+          const md = editor2.action(getMarkdown());
+          const preceding = parseMarkdownOutline(md).filter((item) => item.line <= line).at(-1);
+          if (preceding) scrollHeadingBySlug(editor2, preceding.id);
+        }
+      };
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [getInstance]
+  );
+  return /* @__PURE__ */ jsx12(Milkdown, {});
+});
+var MarkdownEditor = forwardRef6(
+  function MarkdownEditor2({
+    value,
+    defaultValue,
+    onChange,
+    readOnly = false,
+    ariaLabel = "Markdown editor",
+    slashMenu = true,
+    calc,
+    completions,
+    onEmbedAsset,
+    className,
+    style,
+    ...props
+  }, ref) {
+    const initialValue = useRef7(value ?? defaultValue ?? "").current;
+    return /* @__PURE__ */ jsx12(
+      "div",
+      {
+        "data-testid": "markdown-editor",
+        className: cn8(
+          // A 1px hairline focus ring (not a heavy 2px ring) — the editable is a
+          // large surface, so a thinner edit-mode ring reads calmer while still
+          // meeting the visible-focus requirement (same `ring` token). (A7)
+          "milkdown-host overflow-auto rounded-md border border-border bg-background text-foreground focus-within:ring-1 focus-within:ring-ring",
+          className
+        ),
+        style: { ...markdownScaleVars(), ...style },
+        ...props,
+        children: /* @__PURE__ */ jsx12(MilkdownProvider, { children: /* @__PURE__ */ jsx12(ProsemirrorAdapterProvider, { children: /* @__PURE__ */ jsx12(
+          MarkdownEditorView,
+          {
+            ref,
+            initialValue,
+            value,
+            onChange,
+            readOnly,
+            ariaLabel,
+            slashMenu,
+            calc,
+            completions,
+            onEmbedAsset
+          }
+        ) }) })
+      }
+    );
+  }
+);
+
+// src/copy-button/copy-button.tsx
+import { Button, useCopyToClipboard } from "@elabs-ai/components-ui";
+import { cn as cn9 } from "@elabs-ai/components-ui/lib/cn";
+import { CheckIcon, CopyIcon } from "lucide-react";
+import { useCallback as useCallback3 } from "react";
+import { jsx as jsx13, jsxs as jsxs8 } from "react/jsx-runtime";
+function CopyButton({ value, label = true, className, ...props }) {
+  const { copied, copy } = useCopyToClipboard();
+  const onClick = useCallback3(() => {
+    void copy(value);
+  }, [copy, value]);
+  return /* @__PURE__ */ jsxs8(
+    Button,
+    {
+      variant: "ghost",
+      size: "sm",
+      ...props,
+      type: "button",
+      className: cn9("h-7 gap-1.5", className),
+      onClick,
+      "aria-label": copied ? "Copied" : "Copy",
+      children: [
+        copied ? /* @__PURE__ */ jsx13(
+          CheckIcon,
+          {
+            className: "size-4 text-success animate-in fade-in zoom-in-95 duration-fast ease-entrance",
+            "aria-hidden": "true"
+          },
+          String(copied)
+        ) : /* @__PURE__ */ jsx13(CopyIcon, { className: "size-4", "aria-hidden": "true" }),
+        label ? /* @__PURE__ */ jsx13("span", { className: "text-xs", children: copied ? "Copied" : "Copy" }) : null
+      ]
+    }
+  );
+}
+
+// src/lib/editor-content-access.ts
+function monacoContentAccess(editor2) {
+  const readSelection = () => {
+    const model = editor2.getModel();
+    const selection = editor2.getSelection();
+    if (!model || !selection) return { text: "", empty: true };
+    const text = model.getValueInRange(selection);
+    return { text, empty: selection.isEmpty() };
+  };
+  const applyAtSelection = (text) => {
+    const selection = editor2.getSelection();
+    if (!selection) return;
+    editor2.executeEdits("editor-content-access", [
+      { range: selection, text, forceMoveMarkers: true }
+    ]);
+    editor2.pushUndoStop();
+  };
+  return {
+    getText: () => editor2.getValue(),
+    getSelection: readSelection,
+    replaceSelection: applyAtSelection,
+    insertAtCursor: applyAtSelection,
+    focus: () => editor2.focus(),
+    onSelectionChange: (listener2) => {
+      const sub = editor2.onDidChangeCursorSelection(() => listener2(readSelection()));
+      return () => sub.dispose();
+    }
+  };
+}
+
+export {
+  EditorContextMenu,
+  buildBrandThemeData,
+  brandThemeId,
+  applyBrandTheme,
+  useDataTheme,
+  CodeEditor,
+  findCalcFences,
+  calcTokenClassName,
+  identifierPrefix,
+  calcDecorationSpecs,
+  calcInlaySpecs,
+  calcProsePlugins,
+  triggerQueryStart,
+  resolveReplaceRange,
+  collectCompletions,
+  selectionWatchPlugin,
+  proseMirrorContentAccess,
+  MARKDOWN_HEADING_REM,
+  MARKDOWN_HEADING_WEIGHT,
+  MARKDOWN_HEADING_TRACKING,
+  MARKDOWN_MEASURE,
+  markdownScaleVars,
+  IterationEditContext,
+  parseFrontmatter,
+  serializeFrontmatter,
+  parseMarkdownOutline,
+  useMarkdownOutline,
+  DocumentOutline,
+  defaultInterpolate,
+  IterationBlock,
+  ITERATION_LAYOUTS,
+  DEFAULT_TEMPLATE,
+  splitList,
+  parseAttributes,
+  directivePartsFromValue,
+  serializeIterationDirective,
+  builderValueFromParts,
+  parseIterationDirective,
+  emptyBuilderValue,
+  evaluateEmbedded,
+  transposeIterationValue,
+  staticMarkdownFromValue,
+  MetricBlock,
+  insertBrandDirective,
+  insertBasicBlock,
+  CALC_FENCE_SEED,
+  insertCalcFence,
+  resolveCalcInsert,
+  BRAND_SLASH_COMMANDS,
+  filterSlashCommands,
+  groupSlashCommands,
+  DEFAULT_SLASH_SHORTCUT,
+  slashOptionId,
+  SlashMenu,
+  brandSlashViewPlugins,
+  MarkdownEditor,
+  CopyButton,
+  monacoContentAccess
+};
+//# sourceMappingURL=chunk-LBC5VJBD.js.map