@elabs-ai/components-editor 4.0.0

package/dist/markdown/index.js

@@ -0,0 +1,4882 @@
+"use client";
+import "./index.css";
+import {
+  BRAND_SLASH_COMMANDS,
+  CALC_FENCE_SEED,
+  CodeEditor,
+  CopyButton,
+  DEFAULT_SLASH_SHORTCUT,
+  DEFAULT_TEMPLATE,
+  DocumentOutline,
+  ITERATION_LAYOUTS,
+  IterationBlock,
+  IterationEditContext,
+  MARKDOWN_HEADING_REM,
+  MARKDOWN_HEADING_TRACKING,
+  MARKDOWN_HEADING_WEIGHT,
+  MARKDOWN_MEASURE,
+  MarkdownEditor,
+  MetricBlock,
+  SlashMenu,
+  brandSlashViewPlugins,
+  builderValueFromParts,
+  calcDecorationSpecs,
+  calcInlaySpecs,
+  calcProsePlugins,
+  calcTokenClassName,
+  collectCompletions,
+  defaultInterpolate,
+  directivePartsFromValue,
+  emptyBuilderValue,
+  evaluateEmbedded,
+  filterSlashCommands,
+  findCalcFences,
+  groupSlashCommands,
+  identifierPrefix,
+  insertBasicBlock,
+  insertBrandDirective,
+  insertCalcFence,
+  markdownScaleVars,
+  monacoContentAccess,
+  parseAttributes,
+  parseFrontmatter,
+  parseIterationDirective,
+  parseMarkdownOutline,
+  proseMirrorContentAccess,
+  resolveCalcInsert,
+  resolveReplaceRange,
+  selectionWatchPlugin,
+  serializeFrontmatter,
+  serializeIterationDirective,
+  slashOptionId,
+  splitList,
+  staticMarkdownFromValue,
+  transposeIterationValue,
+  triggerQueryStart,
+  useMarkdownOutline
+} from "../chunk-LBC5VJBD.js";
+
+// src/lib/editor-completions-monaco.ts
+import * as monaco from "monaco-editor";
+var REGISTRY = /* @__PURE__ */ new Map();
+var refCount = 0;
+var registration = null;
+function ensureRegistered() {
+  if (registration) return;
+  registration = monaco.languages.registerCompletionItemProvider("markdown", {
+    provideCompletionItems(model, position) {
+      const getProviders = REGISTRY.get(model);
+      if (!getProviders) return { suggestions: [] };
+      const providers = getProviders();
+      if (!providers || providers.length === 0) return { suggestions: [] };
+      const lineText = model.getLineContent(position.lineNumber);
+      const ctx = {
+        source: model.getValue(),
+        line: position.lineNumber,
+        column: position.column,
+        lineText
+      };
+      return collectCompletions(providers, ctx).then((matches) => ({
+        suggestions: matches.map(({ provider, item }) => ({
+          label: item.label,
+          kind: monaco.languages.CompletionItemKind.Text,
+          insertText: item.insertText,
+          detail: item.detail,
+          range: resolveReplaceRange(item, position, lineText, provider.triggerCharacters)
+        }))
+      }));
+    }
+  });
+}
+function attachCompletionsMonaco(editor2, getProviders) {
+  ensureRegistered();
+  refCount++;
+  let model = editor2.getModel();
+  if (model) REGISTRY.set(model, getProviders);
+  const contentSub = editor2.onDidChangeModelContent((e) => {
+    const providers = getProviders();
+    if (!providers || providers.length === 0) return;
+    for (const change of e.changes) {
+      if (change.text.length !== 1) continue;
+      if (providers.some((p) => p.triggerCharacters?.includes(change.text))) {
+        editor2.trigger("brand-completions", "editor.action.triggerSuggest", {});
+        return;
+      }
+    }
+  });
+  const modelSub = editor2.onDidChangeModel(() => {
+    if (model) REGISTRY.delete(model);
+    model = editor2.getModel();
+    if (model) REGISTRY.set(model, getProviders);
+  });
+  return () => {
+    contentSub.dispose();
+    modelSub.dispose();
+    if (model) REGISTRY.delete(model);
+    refCount = Math.max(0, refCount - 1);
+    if (refCount === 0) {
+      registration?.dispose();
+      registration = null;
+    }
+  };
+}
+
+// src/markdown-editor/slash/monaco-slash-menu.tsx
+import { cn } from "@elabs-ai/components-ui/lib/cn";
+import { useEffect, useRef, useState } from "react";
+
+// src/markdown-toolbar/markdown-commands.ts
+import * as monaco2 from "monaco-editor";
+function wrapSelection(editor2, before, after = before, placeholder = "text") {
+  const model = editor2.getModel();
+  const selection = editor2.getSelection();
+  if (!model || !selection) return;
+  const selected = model.getValueInRange(selection) || placeholder;
+  editor2.executeEdits("markdown-toolbar", [
+    { range: selection, text: `${before}${selected}${after}`, forceMoveMarkers: true }
+  ]);
+  const startCol = selection.startColumn + before.length;
+  editor2.setSelection(
+    new monaco2.Selection(
+      selection.startLineNumber,
+      startCol,
+      selection.startLineNumber,
+      startCol + selected.length
+    )
+  );
+  editor2.focus();
+}
+function toggleLinePrefix(editor2, prefix) {
+  const model = editor2.getModel();
+  const selection = editor2.getSelection();
+  if (!model || !selection) return;
+  const edits = [];
+  const allPrefixed = (() => {
+    for (let line = selection.startLineNumber; line <= selection.endLineNumber; line++) {
+      if (!model.getLineContent(line).startsWith(prefix)) return false;
+    }
+    return true;
+  })();
+  for (let line = selection.startLineNumber; line <= selection.endLineNumber; line++) {
+    const content = model.getLineContent(line);
+    if (allPrefixed) {
+      edits.push({
+        range: new monaco2.Range(line, 1, line, prefix.length + 1),
+        text: ""
+      });
+    } else if (!content.startsWith(prefix)) {
+      edits.push({ range: new monaco2.Range(line, 1, line, 1), text: prefix });
+    }
+  }
+  editor2.executeEdits("markdown-toolbar", edits);
+  editor2.focus();
+}
+function insertLink(editor2) {
+  const model = editor2.getModel();
+  const selection = editor2.getSelection();
+  if (!model || !selection) return;
+  const label = model.getValueInRange(selection) || "label";
+  editor2.executeEdits("markdown-toolbar", [
+    { range: selection, text: `[${label}](https://)`, forceMoveMarkers: true }
+  ]);
+  editor2.focus();
+}
+function insertHorizontalRule(editor2) {
+  const selection = editor2.getSelection();
+  if (!selection) return;
+  const line = selection.endLineNumber;
+  const col = editor2.getModel()?.getLineMaxColumn(line) ?? 1;
+  editor2.executeEdits("markdown-toolbar", [
+    { range: new monaco2.Range(line, col, line, col), text: `
+
+---
+`, forceMoveMarkers: true }
+  ]);
+  editor2.focus();
+}
+function insertDirective(editor2, snippet) {
+  const selection = editor2.getSelection();
+  if (!selection) return;
+  const line = selection.endLineNumber;
+  const col = editor2.getModel()?.getLineMaxColumn(line) ?? 1;
+  editor2.executeEdits("markdown-toolbar", [
+    {
+      range: new monaco2.Range(line, col, line, col),
+      text: `
+
+${snippet}
+`,
+      forceMoveMarkers: true
+    }
+  ]);
+  editor2.focus();
+}
+
+// src/markdown-editor/slash/monaco-slash-menu.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var ID_PREFIX = "brand-monaco-slash";
+var LISTBOX_ID = `${ID_PREFIX}-listbox`;
+function getCaretCoords(editor2) {
+  const pos = editor2.getPosition();
+  if (!pos) return null;
+  const scrolled = editor2.getScrolledVisiblePosition(pos);
+  if (!scrolled) return null;
+  const domNode = editor2.getDomNode();
+  if (!domNode) return null;
+  const rect = domNode.getBoundingClientRect();
+  return {
+    top: rect.top + scrolled.top + (scrolled.height ?? 20),
+    left: rect.left + scrolled.left
+  };
+}
+function MonacoSlashMenu({
+  editor: editor2,
+  commands,
+  open,
+  onOpenChange,
+  onInsert,
+  triggerRange,
+  className
+}) {
+  const [query, setQuery] = useState("");
+  const [activeIndex, setActiveIndex] = useState(0);
+  const [coords, setCoords] = useState(null);
+  const menuRef = useRef(null);
+  const commitSnippet = (snippet) => {
+    if (triggerRange) {
+      editor2.executeEdits("brand-slash-typed", [
+        { range: triggerRange, text: snippet, forceMoveMarkers: true }
+      ]);
+    } else {
+      (onInsert ?? insertDirective)(editor2, snippet);
+    }
+    onOpenChange(false);
+    editor2.focus();
+  };
+  const commitRunInSource = (command) => {
+    if (triggerRange) {
+      editor2.executeEdits("brand-slash-typed", [{ range: triggerRange, text: "" }]);
+    }
+    command.runInSource?.({
+      editor: editor2,
+      range: triggerRange ?? null,
+      content: monacoContentAccess(editor2)
+    });
+    onOpenChange(false);
+    editor2.focus();
+  };
+  const selectCommand = (command) => {
+    if (typeof command.runInSource === "function") {
+      commitRunInSource(command);
+    } else if (command.snippet) {
+      commitSnippet(command.snippet);
+    }
+  };
+  const cancel = () => {
+    if (triggerRange) {
+      editor2.executeEdits("brand-slash-cancel", [{ range: triggerRange, text: "" }]);
+    }
+    onOpenChange(false);
+    editor2.focus();
+  };
+  const selectRef = useRef(selectCommand);
+  selectRef.current = selectCommand;
+  const cancelRef = useRef(cancel);
+  cancelRef.current = cancel;
+  useEffect(() => {
+    if (open) {
+      setQuery("");
+      setActiveIndex(0);
+    }
+  }, [open]);
+  useEffect(() => {
+    if (!open) return;
+    const update = () => {
+      setCoords(getCaretCoords(editor2));
+    };
+    update();
+    const scrollSub = editor2.onDidScrollChange(update);
+    const cursorSub = editor2.onDidChangeCursorPosition(update);
+    const onResize = () => update();
+    window.addEventListener("resize", onResize);
+    return () => {
+      scrollSub.dispose();
+      cursorSub.dispose();
+      window.removeEventListener("resize", onResize);
+    };
+  }, [open, editor2]);
+  useEffect(() => {
+    if (!open) return;
+    const blurSub = editor2.onDidBlurEditorText(() => {
+      setTimeout(() => {
+        if (!menuRef.current?.contains(document.activeElement)) {
+          onOpenChange(false);
+        }
+      }, 100);
+    });
+    return () => blurSub.dispose();
+  }, [open, editor2, onOpenChange]);
+  useEffect(() => {
+    if (!open) return;
+    const keydown = (e) => {
+      const filtered2 = filterSlashCommands(commands, query);
+      if (e.key === "Escape") {
+        e.preventDefault();
+        e.stopPropagation();
+        cancelRef.current();
+        return;
+      }
+      if (e.key === "ArrowDown") {
+        e.preventDefault();
+        e.stopPropagation();
+        setActiveIndex((i) => (i + 1) % Math.max(filtered2.length, 1));
+        return;
+      }
+      if (e.key === "ArrowUp") {
+        e.preventDefault();
+        e.stopPropagation();
+        setActiveIndex(
+          (i) => (i - 1 + Math.max(filtered2.length, 1)) % Math.max(filtered2.length, 1)
+        );
+        return;
+      }
+      if (e.key === "Enter" || e.key === "Tab") {
+        e.preventDefault();
+        e.stopPropagation();
+        const command = filtered2[Math.min(activeIndex, filtered2.length - 1)];
+        if (command) selectRef.current(command);
+        return;
+      }
+      if (e.key.length === 1 && !e.ctrlKey && !e.metaKey && !e.altKey) {
+        e.preventDefault();
+        e.stopPropagation();
+        setQuery((q) => q + e.key);
+        setActiveIndex(0);
+        return;
+      }
+      if (e.key === "Backspace") {
+        e.preventDefault();
+        e.stopPropagation();
+        if (query.length === 0) {
+          cancelRef.current();
+          return;
+        }
+        setQuery((q) => q.slice(0, -1));
+        setActiveIndex(0);
+      }
+    };
+    const domNode = editor2.getDomNode();
+    domNode?.addEventListener("keydown", keydown, true);
+    return () => domNode?.removeEventListener("keydown", keydown, true);
+  }, [open, editor2, commands, query, activeIndex]);
+  useEffect(() => {
+    if (!open) return;
+    const filtered2 = filterSlashCommands(commands, query);
+    const active = filtered2[Math.min(activeIndex, Math.max(filtered2.length - 1, 0))];
+    if (!active) return;
+    const el = menuRef.current?.querySelector(
+      `#${CSS.escape(slashOptionId(ID_PREFIX, active.id))}`
+    );
+    el?.scrollIntoView({ block: "nearest" });
+  }, [open, commands, query, activeIndex]);
+  useEffect(() => {
+    if (!open) return;
+    const filtered2 = filterSlashCommands(commands, query);
+    const activeCommand2 = filtered2[Math.min(activeIndex, Math.max(filtered2.length - 1, 0))];
+    const textarea = editor2.getDomNode()?.querySelector("textarea");
+    if (!textarea) return;
+    textarea.setAttribute("aria-expanded", "true");
+    textarea.setAttribute("aria-controls", LISTBOX_ID);
+    if (activeCommand2) {
+      textarea.setAttribute("aria-activedescendant", slashOptionId(ID_PREFIX, activeCommand2.id));
+    } else {
+      textarea.removeAttribute("aria-activedescendant");
+    }
+    return () => {
+      textarea.removeAttribute("aria-expanded");
+      textarea.removeAttribute("aria-controls");
+      textarea.removeAttribute("aria-activedescendant");
+    };
+  }, [open, editor2, commands, query, activeIndex]);
+  if (!open || !coords) return null;
+  const filtered = filterSlashCommands(commands, query);
+  const activeCommand = filtered[Math.min(activeIndex, Math.max(filtered.length - 1, 0))];
+  const handleSelect = (command) => {
+    selectCommand(command);
+  };
+  const resultCount = filtered.length;
+  const statusText = resultCount === 0 ? "No matching blocks" : query ? `${resultCount} result${resultCount === 1 ? "" : "s"} for \u201C${query}\u201D` : `${resultCount} block${resultCount === 1 ? "" : "s"}`;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref: menuRef,
+      className: cn(className),
+      style: { position: "fixed", top: coords.top, left: coords.left, zIndex: 50 },
+      onMouseDown: (e) => e.preventDefault(),
+      children: [
+        /* @__PURE__ */ jsx("span", { role: "status", "aria-live": "polite", className: "sr-only", children: statusText }),
+        query && /* @__PURE__ */ jsxs(
+          "div",
+          {
+            "aria-hidden": "true",
+            className: "mb-0.5 rounded-sm border border-border bg-popover px-2 py-1 text-caption text-muted-foreground",
+            children: [
+              "Filter: ",
+              /* @__PURE__ */ jsx("span", { className: "font-medium text-foreground", children: query })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          SlashMenu,
+          {
+            id: LISTBOX_ID,
+            commands: filtered,
+            activeId: activeCommand?.id,
+            onSelect: handleSelect,
+            idPrefix: ID_PREFIX
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/markdown-workspace/markdown-workspace.tsx
+import {
+  ResizableHandle,
+  ResizablePanel,
+  ResizablePanelGroup,
+  Toggle,
+  ToggleGroup,
+  ToggleGroupItem,
+  Tooltip as Tooltip2,
+  TooltipContent as TooltipContent2,
+  TooltipProvider as TooltipProvider2,
+  TooltipTrigger as TooltipTrigger2
+} from "@elabs-ai/components-ui";
+import { cn as cn13 } from "@elabs-ai/components-ui/lib/cn";
+import { Columns2, Eye, Focus, SquareCode } from "lucide-react";
+import {
+  forwardRef as forwardRef9,
+  useEffect as useEffect5,
+  useImperativeHandle,
+  useMemo as useMemo6,
+  useRef as useRef5,
+  useState as useState5
+} from "react";
+
+// src/calc-block/calc-editor-monaco.ts
+import * as monaco3 from "monaco-editor";
+var REGISTRY2 = /* @__PURE__ */ new Map();
+var providersRegistered = false;
+var inlayEmitter = null;
+function bodyLineTexts(model, fence) {
+  const out = [];
+  for (let ln = fence.bodyStartLine; ln <= fence.bodyEndLine; ln++) {
+    out.push(model.getLineContent(ln));
+  }
+  return out;
+}
+function modelFences(model) {
+  return findCalcFences(model.getValue(monaco3.editor.EndOfLinePreference.LF));
+}
+function buildDecorations(model, hooks) {
+  const decorations = [];
+  for (const fence of modelFences(model)) {
+    if (fence.bodyEndLine < fence.bodyStartLine) continue;
+    const specs = calcDecorationSpecs(hooks, fence.bodyStartLine, bodyLineTexts(model, fence));
+    for (const s of specs) {
+      decorations.push({
+        range: new monaco3.Range(s.lineNumber, s.startColumn, s.lineNumber, s.endColumn),
+        options: { inlineClassName: s.className }
+      });
+    }
+  }
+  return decorations;
+}
+var COMPLETION_KIND = {
+  variable: () => monaco3.languages.CompletionItemKind.Variable,
+  function: () => monaco3.languages.CompletionItemKind.Function,
+  unit: () => monaco3.languages.CompletionItemKind.Unit,
+  currency: () => monaco3.languages.CompletionItemKind.Unit,
+  constant: () => monaco3.languages.CompletionItemKind.Constant,
+  reference: () => monaco3.languages.CompletionItemKind.Reference,
+  keyword: () => monaco3.languages.CompletionItemKind.Keyword,
+  snippet: () => monaco3.languages.CompletionItemKind.Snippet
+};
+function mapCompletionKind(kind) {
+  return (COMPLETION_KIND[kind ?? "variable"] ?? COMPLETION_KIND.variable)();
+}
+function ensureProviders() {
+  if (providersRegistered) return;
+  providersRegistered = true;
+  inlayEmitter = new monaco3.Emitter();
+  monaco3.languages.registerInlayHintsProvider("markdown", {
+    onDidChangeInlayHints: inlayEmitter.event,
+    provideInlayHints(model, range) {
+      const empty = { hints: [], dispose() {
+      } };
+      const hooks = REGISTRY2.get(model)?.();
+      if (!hooks?.evaluate) return empty;
+      const hints = [];
+      for (const fence of modelFences(model)) {
+        if (fence.bodyEndLine < fence.bodyStartLine) continue;
+        if (fence.bodyEndLine < range.startLineNumber || fence.bodyStartLine > range.endLineNumber) {
+          continue;
+        }
+        for (const inlay of calcInlaySpecs(
+          hooks,
+          fence.bodyStartLine,
+          bodyLineTexts(model, fence)
+        )) {
+          hints.push({
+            position: { lineNumber: inlay.lineNumber, column: inlay.column },
+            label: inlay.text,
+            kind: monaco3.languages.InlayHintKind.Type,
+            paddingLeft: true
+          });
+        }
+      }
+      return { hints, dispose() {
+      } };
+    }
+  });
+  monaco3.languages.registerCompletionItemProvider("markdown", {
+    provideCompletionItems(model, position) {
+      const hooks = REGISTRY2.get(model)?.();
+      if (!hooks?.complete) return { suggestions: [] };
+      const fence = modelFences(model).find(
+        (f) => position.lineNumber >= f.bodyStartLine && position.lineNumber <= f.bodyEndLine
+      );
+      if (!fence) return { suggestions: [] };
+      const lines = bodyLineTexts(model, fence);
+      const line = lines[position.lineNumber - fence.bodyStartLine] ?? "";
+      const column = position.column - 1;
+      const prefix = identifierPrefix(line, column);
+      let completions;
+      try {
+        completions = hooks.complete({
+          source: lines.join("\n"),
+          line,
+          lineNumber: position.lineNumber - fence.bodyStartLine + 1,
+          column,
+          prefix
+        });
+      } catch {
+        return { suggestions: [] };
+      }
+      const replace = new monaco3.Range(
+        position.lineNumber,
+        position.column - prefix.length,
+        position.lineNumber,
+        position.column
+      );
+      return {
+        suggestions: completions.map((c) => ({
+          label: c.label,
+          insertText: c.insert,
+          detail: c.detail,
+          kind: mapCompletionKind(c.kind),
+          range: replace
+        }))
+      };
+    }
+  });
+}
+function attachCalcMonaco(editor2, getHooks) {
+  ensureProviders();
+  const collection = editor2.createDecorationsCollection();
+  const subs = [];
+  let model = editor2.getModel();
+  if (model) REGISTRY2.set(model, getHooks);
+  const refresh = () => {
+    const current = editor2.getModel();
+    const hooks = getHooks();
+    if (!current || !hooks) {
+      collection.clear();
+      return;
+    }
+    REGISTRY2.set(current, getHooks);
+    collection.set(buildDecorations(current, hooks));
+    inlayEmitter?.fire();
+  };
+  refresh();
+  subs.push(editor2.onDidChangeModelContent(refresh));
+  subs.push(
+    editor2.onDidChangeModel(() => {
+      if (model) REGISTRY2.delete(model);
+      model = editor2.getModel();
+      refresh();
+    })
+  );
+  return () => {
+    for (const s of subs) s.dispose();
+    collection.clear();
+    if (model) REGISTRY2.delete(model);
+  };
+}
+
+// src/lib/markdown/diff.ts
+var MAX_DIFF_LINES = 5e3;
+var splitLines = (s) => s.split("\n");
+function lcsPairs(a, b) {
+  const n = a.length;
+  const m = b.length;
+  const dp = Array.from({ length: n + 1 }, () => new Uint32Array(m + 1));
+  for (let i2 = n - 1; i2 >= 0; i2--) {
+    const row = dp[i2];
+    const next = dp[i2 + 1];
+    for (let j2 = m - 1; j2 >= 0; j2--) {
+      row[j2] = a[i2] === b[j2] ? next[j2 + 1] + 1 : Math.max(next[j2], row[j2 + 1]);
+    }
+  }
+  const pairs = [];
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (a[i] === b[j]) {
+      pairs.push([i, j]);
+      i++;
+      j++;
+    } else if (dp[i + 1][j] >= dp[i][j + 1]) {
+      i++;
+    } else {
+      j++;
+    }
+  }
+  return pairs;
+}
+function computeMarkdownAnnotations(before, after) {
+  if (before === after) return [];
+  const a = splitLines(before);
+  const b = splitLines(after);
+  if (a.length > MAX_DIFF_LINES || b.length > MAX_DIFF_LINES) return [];
+  const pairs = lcsPairs(a, b);
+  const annotations = [];
+  let prevA = -1;
+  let prevB = -1;
+  const walk = [...pairs, [a.length, b.length]];
+  for (const [ai, bi] of walk) {
+    const removed = ai - prevA - 1;
+    const added = bi - prevB - 1;
+    if (added > 0 && removed > 0) {
+      annotations.push({ kind: "modified", startLine: prevB + 2, endLine: bi });
+    } else if (added > 0) {
+      annotations.push({ kind: "added", startLine: prevB + 2, endLine: bi });
+    } else if (removed > 0) {
+      const anchor = Math.min(bi + 1, b.length);
+      annotations.push({
+        kind: "removed-before",
+        startLine: anchor,
+        endLine: anchor,
+        removedCount: removed
+      });
+    }
+    prevA = ai;
+    prevB = bi;
+  }
+  return mergeAdjacent(annotations);
+}
+function summarizeAnnotations(annotations) {
+  let added = 0;
+  let removed = 0;
+  for (const a of annotations) {
+    const span = a.endLine - a.startLine + 1;
+    if (a.kind === "added") added += span;
+    else if (a.kind === "modified") {
+      added += span;
+      removed += span;
+    } else if (a.kind === "removed-before") removed += a.removedCount ?? 1;
+  }
+  return { added, removed };
+}
+function mergeAdjacent(annotations) {
+  const out = [];
+  for (const ann of annotations) {
+    const last = out[out.length - 1];
+    if (last && last.kind !== "removed-before" && last.kind === ann.kind && ann.startLine <= last.endLine + 1) {
+      last.endLine = Math.max(last.endLine, ann.endLine);
+    } else {
+      out.push({ ...ann });
+    }
+  }
+  return out;
+}
+function shiftAnnotations(annotations, offset) {
+  if (offset === 0) return annotations;
+  const out = [];
+  for (const ann of annotations) {
+    const startLine = ann.startLine - offset;
+    const endLine = ann.endLine - offset;
+    if (endLine < 1) continue;
+    out.push({ ...ann, startLine: Math.max(1, startLine), endLine });
+  }
+  return out;
+}
+function annotationForRange(annotations, startLine, endLine) {
+  let hit;
+  for (const ann of annotations) {
+    if (ann.kind === "removed-before") continue;
+    if (ann.startLine <= endLine && ann.endLine >= startLine) {
+      if (!hit || ann.endLine - ann.startLine < hit.endLine - hit.startLine) hit = ann;
+    }
+  }
+  return hit;
+}
+function removedMarkerAt(annotations, startLine) {
+  return annotations.find((a) => a.kind === "removed-before" && a.startLine === startLine);
+}
+
+// src/lib/markdown/merge.ts
+function alignRegions(o, b) {
+  const pairs = lcsPairs(o, b);
+  const regions = [];
+  let prevO = -1;
+  let prevB = -1;
+  const walk = [...pairs, [o.length, b.length]];
+  for (const [oi, bi] of walk) {
+    if (oi - prevO > 1 || bi - prevB > 1) {
+      regions.push({
+        bStart: prevB + 1,
+        bEnd: bi,
+        oLines: o.slice(prevO + 1, oi),
+        exact: false
+      });
+    }
+    if (oi < o.length && bi < b.length) {
+      regions.push({ bStart: bi, bEnd: bi + 1, oLines: [o[oi]], exact: true });
+    }
+    prevO = oi;
+    prevB = bi;
+  }
+  return regions;
+}
+function mergeNormalizedEdit(original, baseline, edited) {
+  if (baseline === edited) return original;
+  if (original === baseline) return edited;
+  const o = original.split("\n");
+  const b = baseline.split("\n");
+  const n = edited.split("\n");
+  if (o.length > MAX_DIFF_LINES || b.length > MAX_DIFF_LINES || n.length > MAX_DIFF_LINES) {
+    return edited;
+  }
+  const keptB = new Uint8Array(b.length);
+  const inserts = /* @__PURE__ */ new Map();
+  {
+    const pairs = lcsPairs(b, n);
+    let prevB = -1;
+    let prevN = -1;
+    const walk = [...pairs, [b.length, n.length]];
+    for (const [bi, ni] of walk) {
+      if (ni - prevN > 1) inserts.set(bi, n.slice(prevN + 1, ni));
+      if (bi < b.length) keptB[bi] = 1;
+      prevB = bi;
+      prevN = ni;
+    }
+    void prevB;
+  }
+  const regions = alignRegions(o, b);
+  const out = [];
+  const flushInsertsBefore = (bIndex, pendingFrom) => {
+    for (let at = pendingFrom; at <= bIndex; at++) {
+      const ins = inserts.get(at);
+      if (ins) out.push(...ins);
+    }
+    return bIndex + 1;
+  };
+  let insertCursor = 0;
+  for (const region of regions) {
+    if (region.bStart === region.bEnd) {
+      const before = region.bStart - 1;
+      const contextKept = (before < 0 || keptB[before] === 1) && (region.bStart >= b.length || keptB[region.bStart] === 1);
+      insertCursor = flushInsertsBefore(region.bStart - 1, insertCursor);
+      if (contextKept) out.push(...region.oLines);
+      continue;
+    }
+    let allKept = true;
+    for (let bi = region.bStart; bi < region.bEnd; bi++) {
+      if (keptB[bi] !== 1) {
+        allKept = false;
+        break;
+      }
+    }
+    if (region.exact || allKept) {
+      for (let bi = region.bStart; bi < region.bEnd; bi++) {
+        insertCursor = flushInsertsBefore(bi, insertCursor);
+        if (keptB[bi] === 1) {
+          if (region.exact) out.push(...region.oLines);
+        }
+      }
+      if (!region.exact) out.push(...region.oLines);
+    } else {
+      for (let bi = region.bStart; bi < region.bEnd; bi++) {
+        insertCursor = flushInsertsBefore(bi, insertCursor);
+        if (keptB[bi] === 1) out.push(b[bi]);
+      }
+    }
+  }
+  flushInsertsBefore(b.length, insertCursor);
+  return out.join("\n");
+}
+
+// src/markdown-editor/slash/source-slash-trigger.ts
+function slashTriggerRange(line, lineContent, slashColumn) {
+  if (lineContent.charAt(slashColumn - 1) !== "/") return null;
+  if (slashColumn > 1) {
+    const before = lineContent.charAt(slashColumn - 2);
+    if (!/\s/.test(before)) return null;
+  }
+  return {
+    startLineNumber: line,
+    startColumn: slashColumn,
+    endLineNumber: line,
+    endColumn: slashColumn + 1
+  };
+}
+
+// src/markdown-editor/slash/shortcut-monaco.ts
+import * as monaco4 from "monaco-editor";
+var LETTER_KEY_MAP = (() => {
+  const map = {};
+  const kc = monaco4.KeyCode;
+  for (let i = 0; i < 26; i++) {
+    const letter = String.fromCharCode(65 + i);
+    const code = kc[`Key${letter}`];
+    if (code !== void 0) map[letter.toLowerCase()] = code;
+  }
+  return map;
+})();
+var NAMED_KEY_MAP = {
+  "/": monaco4.KeyCode.Slash,
+  backspace: monaco4.KeyCode.Backspace,
+  delete: monaco4.KeyCode.Delete,
+  escape: monaco4.KeyCode.Escape,
+  enter: monaco4.KeyCode.Enter,
+  tab: monaco4.KeyCode.Tab,
+  arrowup: monaco4.KeyCode.UpArrow,
+  arrowdown: monaco4.KeyCode.DownArrow,
+  arrowleft: monaco4.KeyCode.LeftArrow,
+  arrowright: monaco4.KeyCode.RightArrow
+};
+function parseShortcut(shortcut) {
+  const parts = shortcut.split("-");
+  let binding = 0;
+  const keyPart = parts[parts.length - 1] ?? "";
+  const modifiers = parts.slice(0, -1).map((m) => m.toLowerCase());
+  for (const mod of modifiers) {
+    if (mod === "mod") binding |= monaco4.KeyMod.CtrlCmd;
+    else if (mod === "shift") binding |= monaco4.KeyMod.Shift;
+    else if (mod === "alt") binding |= monaco4.KeyMod.Alt;
+    else if (mod === "ctrl") binding |= monaco4.KeyMod.WinCtrl;
+  }
+  const key = keyPart.toLowerCase();
+  const keyCode = NAMED_KEY_MAP[key] ?? LETTER_KEY_MAP[key] ?? (() => {
+    throw new Error(`[@elabs-ai/components-editor] parseShortcut: unrecognized key "${keyPart}"`);
+  })();
+  return binding | keyCode;
+}
+
+// src/markdown-preview/markdown-preview.tsx
+import {
+  Alert,
+  AlertDescription,
+  AlertTitle,
+  Card,
+  CardContent,
+  CardHeader,
+  CardTitle,
+  Separator as Separator3,
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow
+} from "@elabs-ai/components-ui";
+import { cn as cn11 } from "@elabs-ai/components-ui/lib/cn";
+import {
+  createContext as createContext4,
+  forwardRef as forwardRef7,
+  isValidElement,
+  useContext as useContext4,
+  useMemo as useMemo5
+} from "react";
+import {
+  Streamdown,
+  defaultRehypePlugins,
+  defaultRemarkPlugins
+} from "streamdown";
+import { visit as visit5 } from "unist-util-visit";
+
+// src/lib/markdown/directives.ts
+import remarkDirective from "remark-directive";
+import { visit } from "unist-util-visit";
+var BRAND_DIRECTIVES = ["card", "callout", "metric", "timeline"];
+var BRAND_DIRECTIVE_TAG = "brand-directive";
+var BRAND_DIRECTIVE_INLINE_TAG = "brand-directive-inline";
+var BRAND_DIRECTIVE_ATTR = "data-brand";
+var BRAND_DIRECTIVE_PROP = "dataBrand";
+var DIRECTIVE_TYPES = /* @__PURE__ */ new Set(["containerDirective", "leafDirective", "textDirective"]);
+function mdastText(node) {
+  if (typeof node.value === "string") return node.value;
+  if (node.children) return node.children.map(mdastText).join("");
+  return "";
+}
+function extractTimelineItems(node) {
+  const list = node.children?.find((c) => c.type === "list");
+  if (!list?.children) return [];
+  const MARKER = /^\((done|complete|completed|active|current|pending|todo)\)\s*/i;
+  return list.children.filter((c) => c.type === "listItem").map((li) => {
+    let title = mdastText(li).trim();
+    let status = "pending";
+    const marker = title.match(MARKER);
+    if (marker) {
+      status = marker[1].toLowerCase();
+      title = title.slice(marker[0].length).trim();
+    }
+    return { title, status };
+  });
+}
+function cleanAttributes(attrs) {
+  const out = {};
+  for (const [k, v] of Object.entries(attrs ?? {})) {
+    if (typeof v === "string") out[k] = v;
+  }
+  return out;
+}
+function originalText(node, source) {
+  const start = node.position?.start?.offset;
+  const end = node.position?.end?.offset;
+  if (source != null && typeof start === "number" && typeof end === "number") {
+    return source.slice(start, end);
+  }
+  const colons = node.type === "leafDirective" ? "::" : ":";
+  const label = node.children?.length ? `[${mdastText(node)}]` : "";
+  return `${colons}${node.name ?? ""}${label}`;
+}
+function directiveKind(type) {
+  if (type === "containerDirective") return "container";
+  if (type === "leafDirective") return "leaf";
+  return "inline";
+}
+function rawLabel(node, source) {
+  const kids = node.children;
+  if (!source || !kids || kids.length === 0) return void 0;
+  const start = kids[0]?.position?.start?.offset;
+  const end = kids[kids.length - 1]?.position?.end?.offset;
+  if (typeof start === "number" && typeof end === "number") return source.slice(start, end);
+  return void 0;
+}
+function rawContainerBody(node, source) {
+  const kids = node.children;
+  if (!source || !kids || kids.length === 0) return void 0;
+  const body = kids.filter(
+    (c) => !c.data?.directiveLabel
+  );
+  if (body.length === 0) return void 0;
+  const start = body[0]?.position?.start?.offset;
+  const end = body[body.length - 1]?.position?.end?.offset;
+  if (typeof start === "number" && typeof end === "number") return source.slice(start, end).trim();
+  return void 0;
+}
+function remarkBrandDirectives(knownNames = BRAND_DIRECTIVES, rawBodyNames = []) {
+  return (tree, file) => {
+    const source = typeof file?.value === "string" ? file.value : void 0;
+    visit(tree, (node, index, parent) => {
+      if (!DIRECTIVE_TYPES.has(node.type) || !node.name) return void 0;
+      const name = node.name;
+      const known = knownNames.includes(name);
+      const kind = directiveKind(node.type);
+      if (!known && node.type !== "containerDirective" && parent?.children && index != null) {
+        const literal = { type: "text", value: originalText(node, source) };
+        parent.children.splice(
+          index,
+          1,
+          node.type === "leafDirective" ? { type: "paragraph", children: [literal] } : literal
+        );
+        return index + 1;
+      }
+      const payload = {
+        name,
+        known,
+        kind,
+        attributes: cleanAttributes(node.attributes)
+      };
+      if (kind !== "container") {
+        const label = rawLabel(node, source);
+        if (label != null) payload.label = label;
+      }
+      if (kind === "container" && rawBodyNames.includes(name)) {
+        const body = rawContainerBody(node, source);
+        if (body != null) payload.body = body;
+        node.children = [];
+      }
+      if (name === "timeline") {
+        payload.items = extractTimelineItems(node);
+        node.children = [];
+      }
+      const data = node.data ?? (node.data = {});
+      data.hName = kind === "inline" ? BRAND_DIRECTIVE_INLINE_TAG : BRAND_DIRECTIVE_TAG;
+      data.hProperties = { [BRAND_DIRECTIVE_PROP]: JSON.stringify(payload) };
+    });
+  };
+}
+function buildMarkdownPlugins(options = {}) {
+  const known = options.directiveNames && options.directiveNames.length > 0 ? [...BRAND_DIRECTIVES, ...options.directiveNames] : BRAND_DIRECTIVES;
+  const rawBodyNames = options.rawBodyNames ?? [];
+  return [remarkDirective, [remarkBrandDirectives, known, rawBodyNames]];
+}
+
+// src/calc-block/calc-block.tsx
+import { cn as cn2 } from "@elabs-ai/components-ui/lib/cn";
+import { TriangleAlert } from "lucide-react";
+import { forwardRef, useId, useMemo } from "react";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var TINT_MARKERS = {
+  primary: "primary",
+  success: "success",
+  warning: "warning",
+  danger: "destructive",
+  destructive: "destructive",
+  info: "info",
+  muted: "muted",
+  note: "muted"
+};
+var RULE_MARKERS = {
+  line: "single",
+  rule: "single",
+  line2: "double",
+  double: "double",
+  dotted: "dotted"
+};
+function parseMarkers(line) {
+  let text = line;
+  let tint;
+  let rule;
+  for (; ; ) {
+    const m = /\s+@([A-Za-z][A-Za-z0-9]*)\s*$/.exec(text);
+    if (!m) break;
+    const key = (m[1] ?? "").toLowerCase();
+    if (key in TINT_MARKERS) {
+      tint ??= TINT_MARKERS[key];
+    } else if (key in RULE_MARKERS) {
+      rule ??= RULE_MARKERS[key];
+    } else {
+      break;
+    }
+    text = text.slice(0, m.index);
+  }
+  return { text, tint, rule };
+}
+var RULE_CLASS = {
+  dotted: "border-b border-dotted border-border-strong pb-1",
+  single: "border-b border-border-strong pb-1",
+  double: "border-b-4 border-double border-border-strong pb-1"
+};
+var TINT_CLASS = {
+  primary: "bg-primary/10",
+  success: "bg-success/10",
+  warning: "bg-warning/10",
+  destructive: "bg-destructive/10",
+  info: "bg-info/10",
+  muted: "bg-muted"
+};
+function isCalcValue(x) {
+  return typeof x === "object" && x !== null && !("$$typeof" in x) && "kind" in x && "display" in x;
+}
+function tokenClass(kind, resolved) {
+  let base;
+  let role;
+  switch (kind) {
+    case "comment":
+      base = "text-calc-comment italic";
+      role = "brand-calc-tok--comment";
+      break;
+    case "operator":
+      base = "text-calc-operator";
+      role = "brand-calc-tok--operator";
+      break;
+    case "unit":
+      base = "text-calc-unit";
+      role = "brand-calc-tok--unit";
+      break;
+    case "currency":
+      base = "text-calc-currency";
+      role = "brand-calc-tok--currency";
+      break;
+    case "function":
+      base = "text-calc-function";
+      role = "brand-calc-tok--function";
+      break;
+    case "var-ref":
+      base = "text-calc-variable";
+      role = "brand-calc-tok--var-ref";
+      break;
+    case "line-ref":
+      base = "text-calc-reference tabular-nums";
+      role = "brand-calc-tok--line-ref";
+      break;
+    case "var-def":
+      base = "text-calc-variable font-medium";
+      role = "brand-calc-tok--var-def";
+      break;
+    case "unknown":
+      base = "text-calc-warning";
+      role = "brand-calc-tok--unknown";
+      break;
+    default:
+      base = "text-calc-number";
+      role = "brand-calc-tok--number";
+  }
+  return cn2(
+    "brand-calc-tok",
+    role,
+    base,
+    !resolved && "underline decoration-dotted decoration-1 underline-offset-2"
+  );
+}
+function renderSource(text, tokens) {
+  const out = [];
+  let cursor = 0;
+  for (const [i, t] of tokens.entries()) {
+    if (t.start > cursor) {
+      out.push(/* @__PURE__ */ jsx2("span", { children: text.slice(cursor, t.start) }, `gap-${String(i)}`));
+    }
+    out.push(
+      /* @__PURE__ */ jsx2("span", { className: tokenClass(t.kind, t.resolved), children: text.slice(t.start, t.end) }, `tok-${String(i)}`)
+    );
+    cursor = t.end;
+  }
+  if (cursor < text.length) out.push(/* @__PURE__ */ jsx2("span", { children: text.slice(cursor) }, "tail"));
+  if (out.length === 0) out.push(/* @__PURE__ */ jsx2("span", { children: text || " " }, "empty"));
+  return out;
+}
+function ResultCell({ result }) {
+  if (result.error) {
+    return /* @__PURE__ */ jsx2(
+      "span",
+      {
+        className: "inline-flex shrink-0 text-calc-warning",
+        title: result.error.message,
+        "aria-label": `Error: ${result.error.message}`,
+        children: /* @__PURE__ */ jsx2(TriangleAlert, { className: "size-3.5", "aria-hidden": "true" })
+      }
+    );
+  }
+  if (result.value) {
+    return /* @__PURE__ */ jsxs2("div", { className: "brand-calc-tok--result shrink-0 tabular-nums text-calc-result", children: [
+      /* @__PURE__ */ jsx2("span", { className: "sr-only", children: "equals " }),
+      /* @__PURE__ */ jsx2("span", { children: result.value.display })
+    ] });
+  }
+  return null;
+}
+var CalcBlock = forwardRef(function CalcBlock2({
+  source,
+  evaluate,
+  title,
+  showTotal = true,
+  total,
+  totalLabel = "Total",
+  markers = true,
+  readOnly: _readOnly,
+  className,
+  ...props
+}, ref) {
+  const { lines, evalSource, hints } = useMemo(() => {
+    const raw = source.split("\n");
+    if (!markers) return { lines: raw, evalSource: source, hints: [] };
+    const parsed = raw.map(parseMarkers);
+    return {
+      lines: parsed.map((p) => p.text),
+      evalSource: parsed.map((p) => p.text).join("\n"),
+      hints: parsed
+    };
+  }, [source, markers]);
+  const sheet = useMemo(() => evaluate(evalSource), [evaluate, evalSource]);
+  const empty = evalSource.trim() === "";
+  const titleId = useId();
+  const { titleLine, derivedTitle } = useMemo(() => {
+    const idx = lines.findIndex((l) => l.trim() !== "");
+    const first = (lines[idx] ?? "").trim();
+    return /^#+\s+/.test(first) ? { titleLine: idx + 1, derivedTitle: first.replace(/^#+\s*/, "") } : { titleLine: 0, derivedTitle: void 0 };
+  }, [lines]);
+  const hasTitle = title != null || derivedTitle != null;
+  const resolvedTitle = title ?? derivedTitle ?? "calc";
+  const resolvedTotal = total ?? sheet.total;
+  const totalDisplay = isCalcValue(resolvedTotal) ? resolvedTotal.display : resolvedTotal;
+  const rows = [];
+  for (const result of sheet.results) {
+    if (result.line === titleLine) continue;
+    const text = lines[result.line - 1] ?? "";
+    const key = `row-${String(result.line)}`;
+    if (text.trim() === "") {
+      rows.push(/* @__PURE__ */ jsx2("div", { className: "h-1.5", "aria-hidden": "true" }, key));
+      continue;
+    }
+    if (text.trim().startsWith("#")) {
+      rows.push(
+        /* @__PURE__ */ jsx2("div", { className: "pt-1 font-semibold text-foreground first:pt-0", children: text.replace(/^#+\s*/, "") }, key)
+      );
+      continue;
+    }
+    const hint = hints[result.line - 1];
+    const rule = result.rule ?? hint?.rule;
+    const tint = result.tint ?? hint?.tint;
+    rows.push(
+      /* @__PURE__ */ jsxs2(
+        "div",
+        {
+          "data-rule": rule,
+          "data-tint": tint,
+          className: cn2(
+            "flex items-baseline justify-between gap-x-6",
+            rule && RULE_CLASS[rule],
+            tint != null && cn2("-mx-2 rounded-sm px-2", TINT_CLASS[tint])
+          ),
+          children: [
+            /* @__PURE__ */ jsx2("div", { className: "min-w-0 whitespace-pre-wrap break-words text-foreground", children: renderSource(text, result.tokens) }),
+            /* @__PURE__ */ jsx2(ResultCell, { result })
+          ]
+        },
+        key
+      )
+    );
+  }
+  return /* @__PURE__ */ jsxs2(
+    "div",
+    {
+      ref,
+      "data-testid": "calc-block",
+      role: "group",
+      "aria-labelledby": titleId,
+      className: cn2("my-4 overflow-hidden rounded-md border border-border bg-card", className),
+      ...props,
+      children: [
+        /* @__PURE__ */ jsx2("div", { className: "border-b border-border px-4 py-1.5", children: /* @__PURE__ */ jsx2(
+          "span",
+          {
+            id: titleId,
+            className: cn2(
+              "text-meta",
+              hasTitle ? "font-medium text-foreground" : "font-mono uppercase tracking-wide text-muted-foreground"
+            ),
+            children: resolvedTitle
+          }
+        ) }),
+        empty ? /* @__PURE__ */ jsx2("p", { className: "px-4 py-6 text-body text-muted-foreground", children: "Empty calc block." }) : /* @__PURE__ */ jsx2("div", { className: "flex flex-col gap-y-1 px-4 py-3 font-mono text-code leading-relaxed", children: rows }),
+        showTotal && resolvedTotal != null && !empty ? /* @__PURE__ */ jsxs2("div", { className: "flex items-center justify-between border-t border-border px-4 py-2", children: [
+          /* @__PURE__ */ jsx2("span", { className: "text-meta font-medium uppercase tracking-wide text-muted-foreground", children: totalLabel }),
+          /* @__PURE__ */ jsx2("span", { className: "font-mono text-code font-medium tabular-nums text-foreground", children: totalDisplay })
+        ] }) : null
+      ]
+    }
+  );
+});
+
+// src/calc-block/calc-inline.tsx
+import { cn as cn3 } from "@elabs-ai/components-ui/lib/cn";
+import { TriangleAlert as TriangleAlert2 } from "lucide-react";
+import { forwardRef as forwardRef2, useMemo as useMemo2 } from "react";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var CalcInline = forwardRef2(function CalcInline2({ source, evaluate, className, ...props }, ref) {
+  const sheet = useMemo2(() => evaluate(source), [evaluate, source]);
+  const first = sheet.results[0];
+  const display = first?.value?.display;
+  const error = first?.error ?? (display == null ? { message: "No result" } : void 0);
+  if (error) {
+    return /* @__PURE__ */ jsxs3(
+      "span",
+      {
+        ref,
+        "data-testid": "calc-inline",
+        "data-calc-error": "",
+        title: error.message,
+        "aria-label": `${source}: ${error.message}`,
+        className: cn3(
+          "inline-flex items-center gap-0.5 align-baseline font-mono text-calc-warning underline decoration-dotted decoration-1 underline-offset-2",
+          className
+        ),
+        ...props,
+        children: [
+          /* @__PURE__ */ jsx3(TriangleAlert2, { className: "size-3", "aria-hidden": "true" }),
+          /* @__PURE__ */ jsx3("span", { children: source })
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx3(
+    "span",
+    {
+      ref,
+      "data-testid": "calc-inline",
+      title: source,
+      "aria-label": `${source} = ${display}`,
+      className: cn3(
+        "inline-flex items-center rounded-sm bg-calc-result/10 px-1 align-baseline font-mono tabular-nums text-calc-result",
+        className
+      ),
+      ...props,
+      children: display
+    }
+  );
+});
+
+// src/mermaid-diagram/mermaid-diagram.tsx
+import { Button as Button2, Dialog, DialogContent, DialogTitle } from "@elabs-ai/components-ui";
+import { cn as cn5 } from "@elabs-ai/components-ui/lib/cn";
+import { Download, Maximize2 } from "lucide-react";
+import { forwardRef as forwardRef3, useEffect as useEffect3, useRef as useRef3, useState as useState3 } from "react";
+import { oklchToHex } from "@elabs-ai/components-tokens";
+
+// src/mermaid-diagram/mermaid-viewer.tsx
+import { Button, Input } from "@elabs-ai/components-ui";
+import { cn as cn4 } from "@elabs-ai/components-ui/lib/cn";
+import { Maximize, Minus, Plus } from "lucide-react";
+import {
+  useCallback,
+  useEffect as useEffect2,
+  useMemo as useMemo3,
+  useRef as useRef2,
+  useState as useState2
+} from "react";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var MIN_SCALE = 0.2;
+var MAX_SCALE = 6;
+var HIT_CLASS = "wb-dg-hit";
+var HIT_ACTIVE_CLASS = "wb-dg-hit-active";
+var clampScale = (s) => Math.min(MAX_SCALE, Math.max(MIN_SCALE, s));
+function fitTransform(container, natural, pad = 24) {
+  if (container.width <= pad || container.height <= pad) return null;
+  if (!natural.width || !natural.height) return null;
+  const scale = clampScale(
+    Math.min(1, (container.width - pad) / natural.width, (container.height - pad) / natural.height)
+  );
+  return {
+    scale,
+    tx: (container.width - natural.width * scale) / 2,
+    ty: (container.height - natural.height * scale) / 2
+  };
+}
+function diagramNodeLabel(node) {
+  const candidates = Array.from(node.querySelectorAll("tspan, p, span"));
+  const leaves = candidates.filter((el) => !el.querySelector("tspan, p, span"));
+  const parts = leaves.map((el) => (el.textContent ?? "").trim().replace(/\s+/g, " ")).filter(Boolean);
+  if (parts.length === 0) return (node.textContent ?? "").trim().replace(/\s+/g, " ");
+  return parts.join(" \xB7 ");
+}
+function MermaidViewer({ svg, label }) {
+  const containerRef = useRef2(null);
+  const stageRef = useRef2(null);
+  const [transform, setTransform] = useState2({ scale: 1, tx: 0, ty: 0 });
+  const [hits, setHits] = useState2([]);
+  const [query, setQuery] = useState2("");
+  const [activeHit, setActiveHit] = useState2(null);
+  const dragRef = useRef2(null);
+  const userDrivenRef = useRef2(false);
+  const naturalSize = useRef2({ w: 0, h: 0 });
+  const fit = useCallback(() => {
+    const container = containerRef.current;
+    const { w, h } = naturalSize.current;
+    if (!container) return false;
+    const next = fitTransform(
+      { width: container.clientWidth, height: container.clientHeight },
+      { width: w, height: h }
+    );
+    if (next) setTransform(next);
+    return next !== null;
+  }, []);
+  useEffect2(() => {
+    const stage = stageRef.current;
+    const svgEl = stage?.querySelector("svg");
+    if (!stage || !svgEl) return;
+    const viewBox = svgEl.viewBox?.baseVal;
+    const w = viewBox?.width || svgEl.getBoundingClientRect().width || 800;
+    const h = viewBox?.height || svgEl.getBoundingClientRect().height || 600;
+    svgEl.setAttribute("style", `max-width:none;width:${w}px;height:${h}px;`);
+    svgEl.setAttribute("width", String(w));
+    svgEl.setAttribute("height", String(h));
+    const rect = svgEl.getBoundingClientRect();
+    naturalSize.current = {
+      w: rect.width > 0 ? rect.width : w,
+      h: rect.height > 0 ? rect.height : h
+    };
+    const found = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const node of svgEl.querySelectorAll("g.node, g.edgeLabel")) {
+      const text = diagramNodeLabel(node);
+      if (!text || !node.id) continue;
+      if (seen.has(node.id)) continue;
+      seen.add(node.id);
+      found.push({ id: node.id, label: text });
+    }
+    setHits(found);
+    if (!fit()) {
+      let tries = 0;
+      let raf = 0;
+      const attempt = () => {
+        if (userDrivenRef.current) return;
+        if (!fit() && ++tries < 30) raf = requestAnimationFrame(attempt);
+      };
+      raf = requestAnimationFrame(attempt);
+      return () => cancelAnimationFrame(raf);
+    }
+  }, [svg, fit]);
+  useEffect2(() => {
+    const container = containerRef.current;
+    if (!container || typeof ResizeObserver === "undefined") return;
+    const observer = new ResizeObserver(() => {
+      if (!userDrivenRef.current) fit();
+    });
+    observer.observe(container);
+    return () => observer.disconnect();
+  }, [fit]);
+  const q = query.trim().toLowerCase();
+  const matches = useMemo3(
+    () => q.length >= 2 ? hits.filter((hit) => hit.label.toLowerCase().includes(q)) : [],
+    [hits, q]
+  );
+  useEffect2(() => {
+    const svgEl = stageRef.current?.querySelector("svg");
+    if (!svgEl) return;
+    const matchIds = new Set(matches.map((m) => m.id));
+    for (const node of svgEl.querySelectorAll("g.node, g.edgeLabel")) {
+      node.classList.toggle(HIT_CLASS, matchIds.has(node.id));
+      node.classList.toggle(HIT_ACTIVE_CLASS, node.id === activeHit);
+    }
+  }, [matches, activeHit]);
+  const zoomAt = useCallback((clientX, clientY, factor) => {
+    const container = containerRef.current;
+    if (!container) return;
+    userDrivenRef.current = true;
+    const rect = container.getBoundingClientRect();
+    setTransform((t) => {
+      const scale = clampScale(t.scale * factor);
+      const px = (clientX - rect.left - t.tx) / t.scale;
+      const py = (clientY - rect.top - t.ty) / t.scale;
+      return { scale, tx: clientX - rect.left - px * scale, ty: clientY - rect.top - py * scale };
+    });
+  }, []);
+  const zoomCenter = (factor) => {
+    const container = containerRef.current;
+    if (!container) return;
+    const rect = container.getBoundingClientRect();
+    zoomAt(rect.left + rect.width / 2, rect.top + rect.height / 2, factor);
+  };
+  const zoomToHit = useCallback((id) => {
+    const container = containerRef.current;
+    const svgEl = stageRef.current?.querySelector("svg");
+    const node = svgEl?.querySelector(`[id="${CSS.escape(id)}"]`);
+    if (!container || !svgEl || !node) return;
+    userDrivenRef.current = true;
+    setActiveHit(id);
+    setTransform((t) => {
+      const nodeRect = node.getBoundingClientRect();
+      const containerRect = container.getBoundingClientRect();
+      const cx = (nodeRect.left + nodeRect.width / 2 - containerRect.left - t.tx) / t.scale;
+      const cy = (nodeRect.top + nodeRect.height / 2 - containerRect.top - t.ty) / t.scale;
+      const scale = clampScale(Math.max(t.scale, 1.25));
+      return {
+        scale,
+        tx: containerRect.width / 2 - cx * scale,
+        ty: containerRect.height / 2 - cy * scale
+      };
+    });
+  }, []);
+  const onWheel = (e) => {
+    e.preventDefault();
+    zoomAt(e.clientX, e.clientY, e.deltaY < 0 ? 1.12 : 1 / 1.12);
+  };
+  const onPointerDown = (e) => {
+    if (e.button !== 0) return;
+    userDrivenRef.current = true;
+    dragRef.current = { x: e.clientX, y: e.clientY, tx: transform.tx, ty: transform.ty };
+    e.currentTarget.setPointerCapture(e.pointerId);
+  };
+  const onPointerMove = (e) => {
+    const drag = dragRef.current;
+    if (!drag) return;
+    setTransform((t) => ({
+      ...t,
+      tx: drag.tx + (e.clientX - drag.x),
+      ty: drag.ty + (e.clientY - drag.y)
+    }));
+  };
+  const onPointerUp = () => {
+    dragRef.current = null;
+  };
+  return /* @__PURE__ */ jsxs4("div", { className: "flex min-h-0 flex-1 gap-3", children: [
+    /* @__PURE__ */ jsxs4("div", { className: "flex w-60 shrink-0 flex-col border-e border-border pe-3", children: [
+      /* @__PURE__ */ jsx4(
+        Input,
+        {
+          autoFocus: true,
+          type: "search",
+          placeholder: "Find in diagram\u2026",
+          "aria-label": "Find in diagram",
+          value: query,
+          onChange: (e) => setQuery(e.target.value),
+          spellCheck: false,
+          className: "h-8 text-body"
+        }
+      ),
+      /* @__PURE__ */ jsx4("p", { "aria-live": "polite", className: "px-1 pt-1.5 text-meta text-muted-foreground tabular-nums", children: q.length >= 2 ? `${matches.length} ${matches.length === 1 ? "node" : "nodes"}` : `${hits.length} nodes \xB7 type to filter` }),
+      /* @__PURE__ */ jsx4("ul", { className: "m-0 mt-1 min-h-0 flex-1 list-none overflow-auto p-0", children: (q.length >= 2 ? matches : hits).map((hit) => /* @__PURE__ */ jsx4("li", { children: /* @__PURE__ */ jsx4(
+        "button",
+        {
+          type: "button",
+          onClick: () => zoomToHit(hit.id),
+          "aria-pressed": activeHit === hit.id,
+          className: cn4(
+            "w-full truncate rounded-md px-2 py-1.5 text-start text-caption transition-colors duration-fast ease-standard motion-reduce:transition-none",
+            "hover:bg-accent hover:text-accent-foreground",
+            "focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring",
+            activeHit === hit.id ? "bg-accent font-medium text-foreground" : "text-muted-foreground"
+          ),
+          children: hit.label
+        }
+      ) }, hit.id)) })
+    ] }),
+    /* @__PURE__ */ jsxs4("div", { className: "relative min-h-0 min-w-0 flex-1", children: [
+      /* @__PURE__ */ jsxs4("div", { className: "absolute end-2 top-2 z-10 flex gap-1", children: [
+        /* @__PURE__ */ jsx4(
+          Button,
+          {
+            variant: "outline",
+            size: "icon-sm",
+            "aria-label": "Zoom out",
+            onClick: () => zoomCenter(1 / 1.25),
+            children: /* @__PURE__ */ jsx4(Minus, { className: "size-3.5" })
+          }
+        ),
+        /* @__PURE__ */ jsx4(
+          Button,
+          {
+            variant: "outline",
+            size: "icon-sm",
+            "aria-label": "Zoom in",
+            onClick: () => zoomCenter(1.25),
+            children: /* @__PURE__ */ jsx4(Plus, { className: "size-3.5" })
+          }
+        ),
+        /* @__PURE__ */ jsxs4(
+          Button,
+          {
+            variant: "outline",
+            size: "sm",
+            className: "h-7 px-2 font-mono text-meta tabular-nums",
+            "aria-label": "Reset zoom to 100%",
+            onClick: () => {
+              userDrivenRef.current = true;
+              setTransform((t) => ({ ...t, scale: 1 }));
+            },
+            children: [
+              Math.round(transform.scale * 100),
+              "%"
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx4(
+          Button,
+          {
+            variant: "outline",
+            size: "icon-sm",
+            "aria-label": "Fit diagram",
+            onClick: () => {
+              userDrivenRef.current = false;
+              fit();
+            },
+            children: /* @__PURE__ */ jsx4(Maximize, { className: "size-3.5" })
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx4(
+        "div",
+        {
+          ref: containerRef,
+          role: "img",
+          "aria-label": label,
+          className: cn4(
+            "h-full w-full touch-none select-none overflow-hidden rounded-md bg-surface-muted/50",
+            dragRef.current ? "cursor-grabbing" : "cursor-grab"
+          ),
+          onWheel,
+          onPointerDown,
+          onPointerMove,
+          onPointerUp,
+          onPointerCancel: onPointerUp,
+          onDoubleClick: (e) => zoomAt(e.clientX, e.clientY, 1.5),
+          children: /* @__PURE__ */ jsx4(
+            "div",
+            {
+              ref: stageRef,
+              style: {
+                transform: `translate(${transform.tx}px, ${transform.ty}px) scale(${transform.scale})`,
+                transformOrigin: "0 0"
+              },
+              dangerouslySetInnerHTML: { __html: svg }
+            }
+          )
+        }
+      )
+    ] })
+  ] });
+}
+
+// src/mermaid-diagram/remediate.ts
+var FLOWCHART_RESERVED = /* @__PURE__ */ new Set([
+  "graph",
+  "flowchart",
+  "subgraph",
+  "end",
+  "style",
+  "linkstyle",
+  "classdef",
+  "class",
+  "click",
+  "direction",
+  "default",
+  "state"
+]);
+function offendingToken(errorMessage) {
+  const m = /got '([A-Za-z_]+)'/.exec(errorMessage);
+  return m ? m[1].toLowerCase() : null;
+}
+var DECLARATION_RE = /^(graph|flowchart)\s+(tb|td|bt|rl|lr)\s*;?\s*$/;
+function replaceOutsideLabels(line, re, repl) {
+  let out = "";
+  let buf = "";
+  let depth = 0;
+  let inQuote = false;
+  let inPipe = false;
+  const flush = () => {
+    out += buf.replace(re, repl);
+    buf = "";
+  };
+  for (const ch of line) {
+    if (inQuote) {
+      out += ch;
+      if (ch === '"') inQuote = false;
+      continue;
+    }
+    if (depth === 0 && ch === "|") {
+      if (!inPipe) flush();
+      inPipe = !inPipe;
+      out += ch;
+      continue;
+    }
+    if (inPipe) {
+      out += ch;
+      continue;
+    }
+    if (ch === '"') {
+      flush();
+      out += ch;
+      inQuote = true;
+      continue;
+    }
+    if (ch === "[" || ch === "(" || ch === "{") {
+      if (depth === 0) flush();
+      depth++;
+      out += ch;
+      continue;
+    }
+    if (ch === "]" || ch === ")" || ch === "}") {
+      if (depth > 0) depth--;
+      if (depth === 0) {
+        out += ch;
+        continue;
+      }
+      out += ch;
+      continue;
+    }
+    if (depth === 0) buf += ch;
+    else out += ch;
+  }
+  flush();
+  return out;
+}
+function remediateReservedIds(chart, token) {
+  const t = token.toLowerCase();
+  if (!FLOWCHART_RESERVED.has(t)) return null;
+  const re = new RegExp(`\\b${t}\\b`, "gi");
+  let changed = false;
+  const repl = `${t}_`;
+  const out = chart.split("\n").map((line) => {
+    const trimmed = line.trim().toLowerCase();
+    if (trimmed === t) return line;
+    if (DECLARATION_RE.test(trimmed)) return line;
+    if (t === "subgraph" && trimmed.startsWith("subgraph")) return line;
+    const next = replaceOutsideLabels(line, re, repl);
+    if (next !== line) changed = true;
+    return next;
+  }).join("\n");
+  return changed ? out : null;
+}
+
+// src/mermaid-diagram/mermaid-diagram.tsx
+import { Fragment, jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var TOKEN_VARS = {
+  background: "--background",
+  mainBkg: "--card",
+  primaryColor: "--muted",
+  primaryTextColor: "--foreground",
+  primaryBorderColor: "--border-strong",
+  secondaryColor: "--secondary",
+  tertiaryColor: "--muted",
+  lineColor: "--muted-foreground",
+  textColor: "--foreground",
+  nodeBorder: "--border-strong",
+  clusterBkg: "--surface-muted",
+  clusterBorder: "--border",
+  titleColor: "--foreground",
+  edgeLabelBackground: "--background",
+  errorBkgColor: "--destructive",
+  errorTextColor: "--destructive-foreground"
+};
+var renderSeq = 0;
+var HIT_CSS = `
+  .wb-dg-hit :is(rect, polygon, circle, ellipse, path.basic) { stroke: var(--warning) !important; stroke-width: 2.5px !important; }
+  .wb-dg-hit-active :is(rect, polygon, circle, ellipse, path.basic) { stroke: var(--primary) !important; stroke-width: 3px !important; }
+  .wb-dg-hit.edgeLabel { outline: 2px solid var(--warning); border-radius: 2px; }
+  .wb-dg-hit-active.edgeLabel { outline: 2px solid var(--primary); border-radius: 2px; }
+`;
+var KHROMA_SAFE_RE = /^(#|rgba?\(|hsla?\()/i;
+function normalizeColor(value, ctx) {
+  const v = value.trim();
+  if (!v || KHROMA_SAFE_RE.test(v)) return v;
+  const fromOklch = oklchToHex(v);
+  if (fromOklch) return fromOklch;
+  if (ctx) {
+    try {
+      ctx.fillStyle = "#000";
+      ctx.fillStyle = v;
+      if (KHROMA_SAFE_RE.test(ctx.fillStyle)) return ctx.fillStyle;
+    } catch {
+    }
+  }
+  return v;
+}
+function resolveThemeVariables(el) {
+  const styles = getComputedStyle(el);
+  let ctx = null;
+  try {
+    ctx = document.createElement("canvas").getContext("2d");
+  } catch {
+    ctx = null;
+  }
+  const vars = {
+    fontFamily: styles.getPropertyValue("--font-sans").trim() || "inherit"
+  };
+  for (const [mermaidVar, token] of Object.entries(TOKEN_VARS)) {
+    const raw = styles.getPropertyValue(token).trim();
+    if (raw) vars[mermaidVar] = normalizeColor(raw, ctx);
+  }
+  return vars;
+}
+var MermaidDiagram = forwardRef3(
+  function MermaidDiagram2({
+    chart,
+    label = "Diagram",
+    copyable = true,
+    expandable = true,
+    highlightTerm,
+    activeText,
+    className,
+    ...props
+  }, ref) {
+    const hostRef = useRef3(null);
+    const svgHostRef = useRef3(null);
+    const [svg, setSvg] = useState3(null);
+    const [error, setError] = useState3(null);
+    const [expanded, setExpanded] = useState3(false);
+    const downloadSvg = () => {
+      if (!svg) return;
+      const blob = new Blob([svg], { type: "image/svg+xml" });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = `${label.toLowerCase().replace(/[^a-z0-9]+/g, "-") || "diagram"}.svg`;
+      a.click();
+      URL.revokeObjectURL(url);
+    };
+    const [themeVersion, setThemeVersion] = useState3(0);
+    useEffect3(() => {
+      const host = hostRef.current;
+      if (!host) return;
+      const scope = host.closest("[data-theme]") ?? document.documentElement;
+      const observer = new MutationObserver(() => setThemeVersion((v) => v + 1));
+      observer.observe(scope, { attributes: true, attributeFilter: ["data-theme"] });
+      return () => observer.disconnect();
+    }, []);
+    useEffect3(() => {
+      let cancelled = false;
+      const host = hostRef.current;
+      if (!host || !chart.trim()) {
+        setSvg(null);
+        setError(null);
+        return;
+      }
+      (async () => {
+        try {
+          const mermaid = (await import("mermaid")).default;
+          if (cancelled) return;
+          mermaid.initialize({
+            startOnLoad: false,
+            securityLevel: "strict",
+            suppressErrorRendering: true,
+            theme: "base",
+            themeVariables: resolveThemeVariables(host)
+          });
+          const render = (source) => mermaid.render(`brand-mermaid-${++renderSeq}`, source);
+          let out;
+          try {
+            out = await render(chart);
+          } catch (firstErr) {
+            const token = offendingToken(
+              firstErr instanceof Error ? firstErr.message : String(firstErr)
+            );
+            const fixed = token ? remediateReservedIds(chart, token) : null;
+            if (!fixed) throw firstErr;
+            out = await render(fixed);
+          }
+          if (cancelled) return;
+          setSvg(out.svg);
+          setError(null);
+        } catch (err) {
+          if (cancelled) return;
+          setSvg(null);
+          setError(err instanceof Error ? err.message : String(err));
+        }
+      })();
+      return () => {
+        cancelled = true;
+      };
+    }, [chart, themeVersion]);
+    useEffect3(() => {
+      const root = svgHostRef.current;
+      if (!root) return;
+      const term = (highlightTerm ?? "").trim().toLowerCase();
+      const active = (activeText ?? "").trim().toLowerCase();
+      for (const node of root.querySelectorAll("g.node, g.edgeLabel")) {
+        const text = (node.textContent ?? "").trim().toLowerCase();
+        const hit = term.length >= 2 && text.length > 0 && text.includes(term);
+        node.classList.toggle("wb-dg-hit", hit);
+        node.classList.toggle(
+          "wb-dg-hit-active",
+          hit && active.length > 0 && (active.includes(text) || text.includes(active))
+        );
+      }
+    }, [svg, highlightTerm, activeText]);
+    return /* @__PURE__ */ jsxs5(
+      "div",
+      {
+        ref: (el) => {
+          hostRef.current = el;
+          if (typeof ref === "function") ref(el);
+          else if (ref) ref.current = el;
+        },
+        "data-testid": "mermaid-diagram",
+        className: cn5("group/mermaid relative", className),
+        ...props,
+        children: [
+          svg && (copyable || expandable) ? /* @__PURE__ */ jsxs5("div", { className: "absolute end-2 top-2 z-10 flex gap-1 opacity-0 transition-opacity duration-fast ease-standard focus-within:opacity-100 group-hover/mermaid:opacity-100 motion-reduce:transition-none", children: [
+            expandable ? /* @__PURE__ */ jsx5(
+              Button2,
+              {
+                variant: "outline",
+                size: "icon-sm",
+                "aria-label": "Expand diagram",
+                onClick: () => setExpanded(true),
+                children: /* @__PURE__ */ jsx5(Maximize2, { className: "size-3.5" })
+              }
+            ) : null,
+            /* @__PURE__ */ jsx5(
+              Button2,
+              {
+                variant: "outline",
+                size: "icon-sm",
+                "aria-label": "Download diagram as SVG",
+                onClick: downloadSvg,
+                children: /* @__PURE__ */ jsx5(Download, { className: "size-3.5" })
+              }
+            ),
+            copyable ? /* @__PURE__ */ jsx5(
+              CopyButton,
+              {
+                value: chart,
+                label: false,
+                "aria-label": "Copy diagram source",
+                size: "icon-sm"
+              }
+            ) : null
+          ] }) : null,
+          error ? /* @__PURE__ */ jsxs5(
+            "div",
+            {
+              role: "alert",
+              className: "space-y-2 border-s-2 border-s-destructive bg-destructive/10 p-3 text-body",
+              children: [
+                /* @__PURE__ */ jsx5("p", { className: "font-medium text-destructive-text", children: "Diagram failed to render" }),
+                /* @__PURE__ */ jsx5("p", { className: "text-muted-foreground", children: error }),
+                /* @__PURE__ */ jsx5("pre", { className: "overflow-x-auto rounded bg-muted p-2 font-mono text-code text-foreground", children: chart })
+              ]
+            }
+          ) : svg ? /* @__PURE__ */ jsxs5(Fragment, { children: [
+            /* @__PURE__ */ jsx5("style", { children: HIT_CSS }),
+            /* @__PURE__ */ jsx5(
+              "div",
+              {
+                ref: svgHostRef,
+                role: "img",
+                "aria-label": label,
+                className: "overflow-x-auto rounded-md bg-card p-3 [&_svg]:mx-auto [&_svg]:h-auto [&_svg]:max-w-full",
+                dangerouslySetInnerHTML: { __html: svg }
+              }
+            )
+          ] }) : /* @__PURE__ */ jsx5(
+            "div",
+            {
+              role: "status",
+              "aria-label": "Rendering diagram\u2026",
+              className: "h-24 animate-pulse rounded-md bg-surface-muted motion-reduce:animate-none"
+            }
+          ),
+          expandable ? /* @__PURE__ */ jsx5(Dialog, { open: expanded, onOpenChange: setExpanded, children: /* @__PURE__ */ jsxs5(DialogContent, { className: "flex h-[88dvh] w-[92vw] max-w-[92vw] flex-col p-4 sm:max-w-[92vw]", children: [
+            /* @__PURE__ */ jsx5(DialogTitle, { className: "sr-only", children: label }),
+            svg ? /* @__PURE__ */ jsx5(MermaidViewer, { svg, label }) : null
+          ] }) }) : null
+        ]
+      }
+    );
+  }
+);
+
+// src/prose/prose.tsx
+import {
+  ProseHeading,
+  ProseText,
+  ProseLink,
+  ProseList,
+  ProseListItem,
+  ProseBlockquote,
+  ProseInlineCode
+} from "@elabs-ai/components-ui";
+
+// src/timeline/index.ts
+import {
+  Timeline
+} from "@elabs-ai/components-ui";
+
+// src/markdown-preview/code-fence.tsx
+import { cn as cn6 } from "@elabs-ai/components-ui/lib/cn";
+import { code as codeHighlighter } from "@streamdown/code";
+import {
+  useEffect as useEffect4,
+  useRef as useRef4,
+  useState as useState4
+} from "react";
+import { createCssVariablesTheme } from "shiki";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function fenceLanguage(className) {
+  return /\blanguage-([\w+#.-]+)\b/.exec(className ?? "")?.[1];
+}
+var cssVariablesTheme = createCssVariablesTheme({
+  name: "brand-tokens",
+  variablePrefix: "--md-code-",
+  fontStyle: true
+});
+var SHIKI_THEMES = [
+  cssVariablesTheme,
+  cssVariablesTheme
+];
+var SHIKI_TOKEN_VARS = cn6(
+  "[--md-code-foreground:var(--foreground)]",
+  "[--md-code-background:transparent]",
+  "[--md-code-token-comment:var(--muted-foreground)]",
+  "[--md-code-token-constant:var(--chart-1)]",
+  "[--md-code-token-function:var(--chart-3)]",
+  "[--md-code-token-keyword:var(--chart-4)]",
+  "[--md-code-token-link:var(--primary)]",
+  "[--md-code-token-parameter:var(--chart-5)]",
+  "[--md-code-token-punctuation:var(--muted-foreground)]",
+  "[--md-code-token-string-expression:var(--chart-2)]",
+  "[--md-code-token-string:var(--chart-2)]"
+);
+var hasFontFlag = (fontStyle, flag) => ((fontStyle ?? 0) & flag) === flag;
+function tokenStyle(token) {
+  return {
+    // htmlStyle.color carries the theme var; token.color is the fallback path.
+    color: token.htmlStyle?.color ?? token.color,
+    fontStyle: hasFontFlag(token.fontStyle, 1) ? "italic" : void 0,
+    fontWeight: hasFontFlag(token.fontStyle, 2) ? "bold" : void 0,
+    textDecoration: hasFontFlag(token.fontStyle, 4) ? "underline" : void 0
+  };
+}
+function useHighlightedTokens(codeText, language) {
+  const [result, setResult] = useState4(null);
+  const keyRef = useRef4({ codeText, language });
+  if (keyRef.current.codeText !== codeText || keyRef.current.language !== language) {
+    keyRef.current = { codeText, language };
+    setResult(null);
+  }
+  useEffect4(() => {
+    if (!language) return void 0;
+    let cancelled = false;
+    const sync = codeHighlighter.highlight(
+      // Unknown languages fall back to "text" inside the plugin.
+      { code: codeText, language, themes: SHIKI_THEMES },
+      (r) => {
+        if (!cancelled) setResult(r);
+      }
+    );
+    if (sync && !cancelled) setResult(sync);
+    return () => {
+      cancelled = true;
+    };
+  }, [codeText, language]);
+  return result;
+}
+function CodeFence({
+  codeText,
+  language,
+  searchActive,
+  className,
+  children,
+  ...props
+}) {
+  const tokens = useHighlightedTokens(codeText, language)?.tokens ?? null;
+  return /* @__PURE__ */ jsxs6(
+    "div",
+    {
+      "data-code-fence": language ?? "",
+      className: cn6("group/code-fence relative my-3", className),
+      ...props,
+      children: [
+        /* @__PURE__ */ jsx6(
+          "pre",
+          {
+            "data-search-active": searchActive ? "" : void 0,
+            className: cn6(
+              "!my-0 overflow-x-auto rounded-md p-3 font-mono text-code",
+              SHIKI_TOKEN_VARS,
+              searchActive ? "bg-primary/10" : "bg-surface-muted"
+            ),
+            children: tokens ? /* @__PURE__ */ jsx6("code", { children: tokens.map((line, lineIdx) => (
+              // Lines are positionally stable for a given source string (the
+              // whole list is rebuilt when `codeText` changes).
+              /* @__PURE__ */ jsx6("span", { className: "block", children: line.length === 0 ? "\n" : line.map((token, tokenIdx) => /* @__PURE__ */ jsx6("span", { style: tokenStyle(token), children: token.content }, `token-${lineIdx}-${tokenIdx}`)) }, `line-${lineIdx}`)
+            )) }) : children
+          }
+        ),
+        /* @__PURE__ */ jsxs6("div", { className: "absolute end-2 top-2 flex items-center gap-1", children: [
+          /* @__PURE__ */ jsx6(
+            CopyButton,
+            {
+              value: codeText,
+              label: false,
+              size: "icon-sm",
+              className: "opacity-0 transition-opacity duration-fast ease-standard focus-visible:opacity-100 group-hover/code-fence:opacity-100 motion-reduce:transition-none"
+            }
+          ),
+          language ? /* @__PURE__ */ jsx6(
+            "span",
+            {
+              "aria-hidden": "true",
+              className: "pointer-events-none select-none rounded-sm bg-surface-muted px-1.5 py-0.5 font-mono text-meta text-muted-foreground",
+              children: language
+            }
+          ) : null
+        ] })
+      ]
+    }
+  );
+}
+
+// src/markdown-preview/markdown-preview.tsx
+import remarkMath from "remark-math";
+
+// src/markdown-academic/citations.tsx
+import { cn as cn7 } from "@elabs-ai/components-ui/lib/cn";
+import { Separator } from "@elabs-ai/components-ui";
+import {
+  createContext,
+  forwardRef as forwardRef4,
+  useContext,
+  useId as useId2
+} from "react";
+import { visit as visit2 } from "unist-util-visit";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+var ITEM_RE = /^\s*([^@]*?)\s*(-)?@([\p{L}\d][\w:.#$%&+?<>~/-]*)\s*(.*)$/u;
+function parseItem(raw) {
+  const m = ITEM_RE.exec(raw);
+  if (!m) return null;
+  const [, prefix, suppress, key, rest] = m;
+  if (!key) return null;
+  const locator = (rest ?? "").replace(/^\s*,\s*/, "").trim();
+  const item = { key };
+  if (suppress) item.suppressAuthor = true;
+  if (prefix?.trim()) item.prefix = prefix.trim();
+  if (locator) item.locator = locator;
+  return item;
+}
+function parseCitationBracket(inner) {
+  if (!inner.includes("@")) return null;
+  const items = [];
+  for (const part of inner.split(";")) {
+    const item = parseItem(part);
+    if (!item) return null;
+    items.push(item);
+  }
+  return items.length > 0 ? items : null;
+}
+var BRACKET_RE = /(?<![\]!])\[([^[\]]+)\](?![([])/g;
+function collectCitations(markdown, resolve) {
+  const byKey = /* @__PURE__ */ new Map();
+  const order = [];
+  let m;
+  BRACKET_RE.lastIndex = 0;
+  while ((m = BRACKET_RE.exec(markdown)) !== null) {
+    const items = parseCitationBracket(m[1]);
+    if (!items) continue;
+    for (const { key } of items) {
+      if (byKey.has(key)) continue;
+      const data = resolve(key);
+      const entry = { key, data };
+      if (data) {
+        entry.n = order.length + 1;
+        order.push(entry);
+      }
+      byKey.set(key, entry);
+    }
+  }
+  return { order, byKey };
+}
+var CITE_TAG = "brand-cite";
+var CITE_PROP = "dataCite";
+var CITE_ATTR = "data-cite";
+function remarkBrandCitations() {
+  return (tree) => {
+    visit2(tree, "text", (node, index, parent) => {
+      const p = parent;
+      const text = node.value;
+      if (!p?.children || index == null || typeof text !== "string" || !text.includes("@")) return;
+      const next = [];
+      let last = 0;
+      BRACKET_RE.lastIndex = 0;
+      let m;
+      while ((m = BRACKET_RE.exec(text)) !== null) {
+        const items = parseCitationBracket(m[1]);
+        if (!items) continue;
+        if (m.index > last) next.push({ type: "text", value: text.slice(last, m.index) });
+        const payload = { items, original: m[0] };
+        next.push({
+          type: "brandCite",
+          data: { hName: CITE_TAG, hProperties: { [CITE_PROP]: JSON.stringify(payload) } }
+        });
+        last = m.index + m[0].length;
+      }
+      if (next.length === 0) return;
+      if (last < text.length) next.push({ type: "text", value: text.slice(last) });
+      p.children.splice(index, 1, ...next);
+      return index + next.length;
+    });
+  };
+}
+var CitationContext = createContext(null);
+function CitationProvider({ byKey, order, style, children }) {
+  return /* @__PURE__ */ jsx7(CitationContext.Provider, { value: { byKey, order, style }, children });
+}
+function hoverTitle(data) {
+  if (data.formatted) return data.formatted;
+  const parts = [
+    data.author,
+    data.year != null ? `(${data.year})` : void 0,
+    data.title,
+    data.container
+  ].filter(Boolean);
+  return parts.join(". ");
+}
+function CiteLink({ entry, label }) {
+  const name = entry.data ? hoverTitle(entry.data) : entry.key;
+  return /* @__PURE__ */ jsx7(
+    "a",
+    {
+      href: `#ref-${cssId(entry.key)}`,
+      title: entry.data ? hoverTitle(entry.data) : void 0,
+      "aria-label": `Citation: ${name}`,
+      className: "text-primary-text underline hover:underline focus-visible:rounded-sm focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
+      children: label
+    }
+  );
+}
+function cssId(key) {
+  return key.replace(/[^\w-]/g, "-");
+}
+function readCite(rest) {
+  const raw = rest[CITE_ATTR] ?? rest[CITE_PROP];
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function InlineCite({ node: _n, children: _c, ...rest }) {
+  const ctx = useContext(CitationContext);
+  const payload = readCite(rest);
+  if (!payload) return null;
+  if (!ctx) return /* @__PURE__ */ jsx7("span", { children: payload.original });
+  const resolved = payload.items.map((it) => ({ it, entry: ctx.byKey.get(it.key) }));
+  const anyResolved = resolved.some((r) => r.entry?.data);
+  if (!anyResolved) {
+    return /* @__PURE__ */ jsx7("span", { className: "text-muted-foreground", title: "Unresolved citation", children: payload.original });
+  }
+  const numeric = ctx.style === "numeric";
+  const open = numeric ? "[" : "(";
+  const close = numeric ? "]" : ")";
+  const sep = numeric ? ", " : "; ";
+  return /* @__PURE__ */ jsxs7("span", { className: "whitespace-nowrap text-meta tabular-nums", children: [
+    open,
+    resolved.map(({ it, entry }, i) => {
+      const label = numeric ? numericLabel(it, entry) : authorYearLabel(it, entry);
+      return /* @__PURE__ */ jsxs7("span", { children: [
+        i > 0 ? sep : null,
+        entry?.data ? /* @__PURE__ */ jsx7(CiteLink, { entry, label }) : /* @__PURE__ */ jsx7("span", { className: "text-muted-foreground", title: `Unresolved: @${it.key}`, children: label })
+      ] }, `${it.key}-${i}`);
+    }),
+    close
+  ] });
+}
+function numericLabel(it, entry) {
+  if (!entry?.data || entry.n == null) return "?";
+  return it.locator ? `${entry.n}, ${it.locator}` : String(entry.n);
+}
+function authorYearLabel(it, entry) {
+  if (!entry?.data) return `@${it.key}?`;
+  const d = entry.data;
+  const head = it.suppressAuthor ? "" : d.author ? `${d.author} ` : "";
+  const year = d.year != null ? String(d.year) : "";
+  const core = `${head}${year}`.trim() || d.title || it.key;
+  const prefixed = it.prefix ? `${it.prefix} ${core}` : core;
+  return it.locator ? `${prefixed}, ${it.locator}` : prefixed;
+}
+function assembledReference(data) {
+  if (data.formatted) return data.formatted;
+  const parts = [
+    data.author,
+    data.year != null ? `(${data.year}).` : void 0,
+    data.title ? `${data.title}.` : void 0,
+    data.container ? `${data.container}.` : void 0
+  ].filter(Boolean);
+  return parts.join(" ");
+}
+function referenceHref(data) {
+  if (data.url) return data.url;
+  if (data.doi) return `https://doi.org/${data.doi}`;
+  return void 0;
+}
+var Bibliography = forwardRef4(function Bibliography2({ entries, style, title = "References", className, ...props }, ref) {
+  const ctx = useContext(CitationContext);
+  const labelId = useId2();
+  const list = entries ?? ctx?.order ?? [];
+  const resolvedStyle = style ?? ctx?.style ?? "numeric";
+  const numeric = resolvedStyle === "numeric";
+  if (list.length === 0) return null;
+  return /* @__PURE__ */ jsxs7("section", { ref, "aria-labelledby": labelId, className: cn7("mt-8", className), ...props, children: [
+    /* @__PURE__ */ jsx7(Separator, { className: "mb-3" }),
+    /* @__PURE__ */ jsx7("p", { id: labelId, className: "mb-2 text-meta font-medium text-muted-foreground", children: title }),
+    /* @__PURE__ */ jsx7("ol", { className: "space-y-2", children: list.map((entry) => {
+      const data = entry.data;
+      if (!data) return null;
+      const href = referenceHref(data);
+      return /* @__PURE__ */ jsxs7(
+        "li",
+        {
+          id: `ref-${cssId(entry.key)}`,
+          className: "flex gap-2 text-caption text-foreground scroll-mt-4",
+          children: [
+            numeric && entry.n != null ? /* @__PURE__ */ jsxs7("span", { className: "shrink-0 tabular-nums text-muted-foreground", children: [
+              "[",
+              entry.n,
+              "]"
+            ] }) : null,
+            /* @__PURE__ */ jsxs7("span", { className: "min-w-0", children: [
+              assembledReference(data),
+              " ",
+              href ? /* @__PURE__ */ jsx7(
+                "a",
+                {
+                  href,
+                  target: "_blank",
+                  rel: "noopener noreferrer",
+                  className: "break-words text-primary-text underline underline-offset-2 hover:underline focus-visible:rounded-sm focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
+                  children: data.url ?? `doi:${data.doi}`
+                }
+              ) : null
+            ] })
+          ]
+        },
+        entry.key
+      );
+    }) })
+  ] });
+});
+
+// src/markdown-academic/footnotes.tsx
+import { Separator as Separator2 } from "@elabs-ai/components-ui";
+import { cn as cn8 } from "@elabs-ai/components-ui/lib/cn";
+import { forwardRef as forwardRef5, useId as useId3 } from "react";
+import { visit as visit3 } from "unist-util-visit";
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+var FOOTNOTE_REF_TAG = "brand-footnote-ref";
+var FOOTNOTE_LIST_TAG = "brand-footnote-list";
+var FOOTNOTE_ITEM_TAG = "brand-footnote-item";
+var FOOTNOTE_PROP = "dataFn";
+var FOOTNOTE_ATTR = "data-fn";
+function payloadProps(payload) {
+  return { [FOOTNOTE_PROP]: JSON.stringify(payload) };
+}
+function remarkBrandFootnotes() {
+  return (tree) => {
+    const root = tree;
+    const defs = /* @__PURE__ */ new Map();
+    visit3(
+      root,
+      "footnoteDefinition",
+      (node, index, parent) => {
+        if (!node.identifier || !parent?.children || index == null) return;
+        defs.set(node.identifier, node);
+        parent.children.splice(index, 1);
+        return index;
+      }
+    );
+    const numberOf = /* @__PURE__ */ new Map();
+    const refsOf = /* @__PURE__ */ new Map();
+    const order = [];
+    visit3(root, "footnoteReference", (node, index, parent) => {
+      if (!node.identifier || !parent?.children || index == null) return;
+      const id = node.identifier;
+      let n = numberOf.get(id);
+      if (n == null) {
+        n = order.length + 1;
+        numberOf.set(id, n);
+        order.push(id);
+      }
+      const refs = refsOf.get(id) ?? [];
+      const refId = refs.length === 0 ? `fnref-${id}` : `fnref-${id}-${refs.length + 1}`;
+      refs.push(refId);
+      refsOf.set(id, refs);
+      parent.children[index] = {
+        type: "brandFootnoteRef",
+        data: { hName: FOOTNOTE_REF_TAG, hProperties: payloadProps({ id, n, refId }) }
+      };
+    });
+    if (order.length === 0) return;
+    const items = order.map((id, i) => {
+      const def = defs.get(id);
+      const body = def?.children ? def.children.map((c) => structuredClone(c)) : [{ type: "paragraph", children: [{ type: "text", value: "Missing footnote." }] }];
+      return {
+        type: "brandFootnoteItem",
+        data: {
+          hName: FOOTNOTE_ITEM_TAG,
+          hProperties: payloadProps({ id, n: i + 1, refs: refsOf.get(id) ?? [`fnref-${id}`] })
+        },
+        children: body
+      };
+    });
+    root.children = root.children ?? [];
+    root.children.push({
+      type: "brandFootnoteList",
+      data: { hName: FOOTNOTE_LIST_TAG },
+      children: items
+    });
+  };
+}
+function readPayload(rest) {
+  const raw = rest[FOOTNOTE_ATTR] ?? rest[FOOTNOTE_PROP];
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function FootnoteRef({ node: _n, children: _c, ...rest }) {
+  const payload = readPayload(rest);
+  if (!payload) return null;
+  const { id, n, refId } = payload;
+  return /* @__PURE__ */ jsx8("sup", { className: "leading-none", children: /* @__PURE__ */ jsx8(
+    "a",
+    {
+      id: refId ?? `fnref-${id}`,
+      href: `#fn-${id}`,
+      "data-footnote-ref": "",
+      "aria-label": `Footnote ${n}`,
+      className: "px-0.5 font-medium text-primary-text underline tabular-nums hover:underline focus-visible:rounded-sm focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
+      children: n
+    }
+  ) });
+}
+function FootnoteItem({ node: _n, children, ...rest }) {
+  const payload = readPayload(rest);
+  if (!payload) return null;
+  const { id, n, refs } = payload;
+  const refList = refs && refs.length > 0 ? refs : [`fnref-${id}`];
+  return /* @__PURE__ */ jsxs8(
+    "li",
+    {
+      id: `fn-${id}`,
+      className: "scroll-mt-4 ps-1 [&>p]:m-0 [&>p]:inline [&>p]:text-caption [&>p]:text-muted-foreground",
+      children: [
+        children,
+        " ",
+        refList.map((refId, i) => /* @__PURE__ */ jsxs8(
+          "a",
+          {
+            href: `#${refId}`,
+            "data-footnote-backref": "",
+            "aria-label": refList.length > 1 ? `Back to reference ${n}, mention ${i + 1}` : `Back to reference ${n}`,
+            className: "ms-0.5 inline-flex items-center text-muted-foreground no-underline hover:text-foreground focus-visible:rounded-sm focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
+            children: [
+              /* @__PURE__ */ jsx8("span", { "aria-hidden": "true", children: "\u21A9" }),
+              refList.length > 1 ? /* @__PURE__ */ jsx8("sub", { className: "ms-0.5 leading-none tabular-nums", children: i + 1 }) : null
+            ]
+          },
+          refId
+        ))
+      ]
+    }
+  );
+}
+var FootnoteList = forwardRef5(function FootnoteList2({ className, children, ...props }, ref) {
+  const labelId = useId3();
+  return /* @__PURE__ */ jsxs8("section", { ref, "aria-labelledby": labelId, className: cn8("mt-8", className), ...props, children: [
+    /* @__PURE__ */ jsx8(Separator2, { className: "mb-3" }),
+    /* @__PURE__ */ jsx8("p", { id: labelId, className: "mb-2 text-meta font-medium text-muted-foreground", children: "Footnotes" }),
+    /* @__PURE__ */ jsx8("ol", { className: "list-decimal space-y-1.5 ps-6 text-caption text-muted-foreground marker:text-muted-foreground", children })
+  ] });
+});
+
+// src/markdown-academic/math.tsx
+import { cn as cn9 } from "@elabs-ai/components-ui/lib/cn";
+import katex from "katex";
+import { useMemo as useMemo4 } from "react";
+import { visit as visit4 } from "unist-util-visit";
+import { jsx as jsx9 } from "react/jsx-runtime";
+var MATH_BLOCK_TAG = "brand-math";
+var MATH_INLINE_TAG = "brand-math-inline";
+var MATH_PROP = "dataTex";
+var MATH_ATTR = "data-tex";
+var MAX_EXPAND = 1e3;
+function remarkBrandMath() {
+  return (tree) => {
+    visit4(tree, (node, index, parent) => {
+      if (node.type !== "inlineMath" && node.type !== "math") return;
+      if (!parent?.children || index == null) return;
+      const display = node.type === "math";
+      const tex = typeof node.value === "string" ? node.value : "";
+      parent.children[index] = {
+        type: display ? "brandMathBlock" : "brandMathInline",
+        data: {
+          hName: display ? MATH_BLOCK_TAG : MATH_INLINE_TAG,
+          hProperties: { [MATH_PROP]: tex }
+        }
+      };
+    });
+  };
+}
+function readTex(rest) {
+  return rest[MATH_ATTR] ?? rest[MATH_PROP] ?? "";
+}
+function renderKatex(tex, displayMode) {
+  try {
+    return {
+      html: katex.renderToString(tex, {
+        displayMode,
+        throwOnError: false,
+        errorColor: "var(--destructive)",
+        trust: false,
+        maxExpand: MAX_EXPAND,
+        strict: "ignore",
+        output: "htmlAndMathml"
+      }),
+      error: false
+    };
+  } catch {
+    return { html: "", error: true };
+  }
+}
+function MathInline({ tex, className, ...props }) {
+  const { html, error } = useMemo4(() => renderKatex(tex, false), [tex]);
+  if (error) {
+    return /* @__PURE__ */ jsx9(
+      "code",
+      {
+        className: cn9("text-destructive-text", className),
+        "aria-label": `Math (could not render): ${tex}`,
+        title: "Could not render math",
+        ...props,
+        children: tex
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx9(
+    "span",
+    {
+      role: "math",
+      "aria-label": tex,
+      className: cn9("inline-block align-middle", className),
+      dangerouslySetInnerHTML: { __html: html },
+      ...props
+    }
+  );
+}
+function MathBlock({ tex, className, ...props }) {
+  const { html, error } = useMemo4(() => renderKatex(tex, true), [tex]);
+  if (error) {
+    return /* @__PURE__ */ jsx9(
+      "pre",
+      {
+        className: cn9(
+          "overflow-x-auto rounded-md bg-surface-muted p-3 text-destructive-text",
+          className
+        ),
+        "aria-label": `Math (could not render): ${tex}`,
+        title: "Could not render math",
+        ...props,
+        children: /* @__PURE__ */ jsx9("code", { children: tex })
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx9(
+    "div",
+    {
+      role: "math",
+      "aria-label": tex,
+      className: cn9("my-3 overflow-x-auto text-center", className),
+      dangerouslySetInnerHTML: { __html: html },
+      ...props
+    }
+  );
+}
+function MathInlineTag({ node: _n, children: _c, ...rest }) {
+  return /* @__PURE__ */ jsx9(MathInline, { tex: readTex(rest) });
+}
+function MathBlockTag({ node: _n, children: _c, ...rest }) {
+  return /* @__PURE__ */ jsx9(MathBlock, { tex: readTex(rest) });
+}
+
+// src/markdown-academic/toc.tsx
+import { cn as cn10 } from "@elabs-ai/components-ui/lib/cn";
+import { createContext as createContext2, forwardRef as forwardRef6, useContext as useContext2 } from "react";
+import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
+var INDENT = ["ps-0", "ps-3", "ps-6", "ps-9", "ps-12", "ps-12"];
+var TocContext = createContext2(null);
+function TocProvider({ items, children }) {
+  const idByLine = /* @__PURE__ */ new Map();
+  for (const it of items) idByLine.set(it.line, it.id);
+  return /* @__PURE__ */ jsx10(TocContext.Provider, { value: { items, idByLine }, children });
+}
+function useHeadingId(line) {
+  const ctx = useContext2(TocContext);
+  if (line == null || !ctx) return void 0;
+  return ctx.idByLine.get(line);
+}
+var TableOfContents = forwardRef6(
+  function TableOfContents2({ items, title = "Contents", maxLevel = 3, className, ...props }, ref) {
+    const ctx = useContext2(TocContext);
+    const source = items ?? ctx?.items ?? [];
+    const list = source.filter((it) => it.level <= maxLevel);
+    if (list.length === 0) return null;
+    const minLevel = Math.min(...list.map((it) => it.level));
+    return /* @__PURE__ */ jsxs9("nav", { ref, "aria-label": title, className: cn10("my-4 text-meta", className), ...props, children: [
+      /* @__PURE__ */ jsx10("p", { className: "mb-2 font-medium text-muted-foreground", children: title }),
+      /* @__PURE__ */ jsx10("ol", { className: "space-y-1", children: list.map((it) => /* @__PURE__ */ jsx10("li", { className: INDENT[Math.min(it.level - minLevel, INDENT.length - 1)], children: /* @__PURE__ */ jsx10(
+        "a",
+        {
+          href: `#${it.id}`,
+          className: "text-muted-foreground underline hover:text-foreground hover:underline focus-visible:rounded-sm focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
+          children: it.text
+        }
+      ) }, it.id)) })
+    ] });
+  }
+);
+
+// src/markdown-iteration/directive.tsx
+import { createContext as createContext3, useContext as useContext3 } from "react";
+import { jsx as jsx11 } from "react/jsx-runtime";
+var MAX_ITERATION_DEPTH = 3;
+var IterationDepthContext = createContext3(0);
+var DEFAULT_LAYOUT = {
+  iterate: "stacked",
+  pivot: "matrix"
+};
+var LAYOUTS = /* @__PURE__ */ new Set(["stacked", "grid", "matrix", "bento"]);
+function specFromDirective(name, attributes, rawBody) {
+  const kind = name;
+  const layoutAttr = attributes.layout;
+  const layout = layoutAttr && LAYOUTS.has(layoutAttr) ? layoutAttr : DEFAULT_LAYOUT[kind];
+  const columns = attributes.columns ? Number(attributes.columns) || void 0 : void 0;
+  return {
+    kind,
+    layout,
+    template: rawBody ?? "",
+    as: attributes.as?.trim() || "item",
+    source: attributes.source,
+    rows: attributes.rows,
+    cols: attributes.cols,
+    columns,
+    attributes
+  };
+}
+function IterationDirective({
+  spec,
+  evaluate,
+  interpolate,
+  renderCell
+}) {
+  const depth = useContext3(IterationDepthContext);
+  if (depth >= MAX_ITERATION_DEPTH) {
+    return /* @__PURE__ */ jsx11("div", { className: "my-4 text-meta text-muted-foreground italic", "data-iteration-too-deep": "", children: "Iteration nested too deep \u2014 skipped." });
+  }
+  return /* @__PURE__ */ jsx11(IterationDepthContext.Provider, { value: depth + 1, children: /* @__PURE__ */ jsx11(
+    IterationBlock,
+    {
+      spec,
+      evaluate,
+      interpolate,
+      render: renderCell
+    }
+  ) });
+}
+
+// src/markdown-preview/markdown-preview.tsx
+import { Fragment as Fragment2, jsx as jsx12, jsxs as jsxs10 } from "react/jsx-runtime";
+var baseRemarkPlugins = Object.values(defaultRemarkPlugins);
+var BRAND_TRANSCLUSION_TAG = "brand-transclusion";
+var BRAND_TRANSCLUSION_ATTR = "data-transclusion";
+var BRAND_TRANSCLUSION_PROP = "dataTransclusion";
+var allowedTags = {
+  [BRAND_DIRECTIVE_TAG]: [BRAND_DIRECTIVE_PROP],
+  [BRAND_DIRECTIVE_INLINE_TAG]: [BRAND_DIRECTIVE_PROP],
+  [BRAND_TRANSCLUSION_TAG]: [BRAND_TRANSCLUSION_PROP],
+  // Academic layer (footnotes / math / citations) — opt-in via props, but the
+  // tags are always allow-listed (harmless when the feature is off).
+  [FOOTNOTE_REF_TAG]: [FOOTNOTE_PROP],
+  [FOOTNOTE_ITEM_TAG]: [FOOTNOTE_PROP],
+  [FOOTNOTE_LIST_TAG]: [],
+  [MATH_BLOCK_TAG]: [MATH_PROP],
+  [MATH_INLINE_TAG]: [MATH_PROP],
+  [CITE_TAG]: [CITE_PROP]
+};
+var ACADEMIC_TAGS = [
+  FOOTNOTE_REF_TAG,
+  FOOTNOTE_ITEM_TAG,
+  FOOTNOTE_LIST_TAG,
+  MATH_BLOCK_TAG,
+  MATH_INLINE_TAG,
+  CITE_TAG
+];
+var ACADEMIC_TAG_ATTRS = {
+  [FOOTNOTE_REF_TAG]: [FOOTNOTE_PROP],
+  [FOOTNOTE_ITEM_TAG]: [FOOTNOTE_PROP],
+  [FOOTNOTE_LIST_TAG]: [],
+  [MATH_BLOCK_TAG]: [MATH_PROP],
+  [MATH_INLINE_TAG]: [MATH_PROP],
+  [CITE_TAG]: [CITE_PROP]
+};
+var rehypePlugins = (() => {
+  const defaults = defaultRehypePlugins;
+  const sanitize = defaults.sanitize;
+  const schema = sanitize[1] ?? {};
+  const protocols = schema.protocols ?? {};
+  const extendedSanitize = [
+    sanitize[0],
+    {
+      ...schema,
+      protocols: { ...protocols, src: [...protocols.src ?? ["http", "https"], "data", "blob"] },
+      // Custom rehypePlugins bypass Streamdown's `allowedTags` merge — so the brand-directive
+      // tags, the transclusion tag, and their JSON payload properties all go into the schema here.
+      tagNames: [
+        ...schema.tagNames ?? [],
+        BRAND_DIRECTIVE_TAG,
+        BRAND_DIRECTIVE_INLINE_TAG,
+        BRAND_TRANSCLUSION_TAG,
+        ...ACADEMIC_TAGS
+      ],
+      attributes: {
+        ...schema.attributes ?? {},
+        [BRAND_DIRECTIVE_TAG]: [BRAND_DIRECTIVE_PROP],
+        [BRAND_DIRECTIVE_INLINE_TAG]: [BRAND_DIRECTIVE_PROP],
+        [BRAND_TRANSCLUSION_TAG]: [BRAND_TRANSCLUSION_PROP],
+        ...ACADEMIC_TAG_ATTRS
+      }
+    }
+  ];
+  return [defaults.raw, extendedSanitize, defaults.harden];
+})();
+var singleBlock = (md) => [md];
+var AnnotationsContext = createContext4([]);
+var SearchContext = createContext4({ lines: [] });
+var HeadingActionsContext = createContext4(
+  null
+);
+var EMPTY_REGISTRY = { directives: /* @__PURE__ */ new Map(), fences: /* @__PURE__ */ new Map() };
+var RegistryContext = createContext4(EMPTY_REGISTRY);
+var LinkPreviewContext = createContext4(
+  null
+);
+var TransclusionResolverContext = createContext4(null);
+var TRANSCLUSION_MAX_DEPTH = 3;
+var TransclusionDepthContext = createContext4(0);
+function flattenNodeText(node) {
+  if (typeof node === "string" || typeof node === "number") return String(node);
+  if (Array.isArray(node)) return node.map((n) => flattenNodeText(n)).join("");
+  if (isValidElement(node)) {
+    return flattenNodeText(node.props.children);
+  }
+  return "";
+}
+function remarkResolveUrls(resolve) {
+  return function attacher() {
+    return (tree) => {
+      visit5(tree, (node) => {
+        const n = node;
+        if (n.type === "image" || n.type === "imageReference") {
+          if (typeof n.url === "string") n.url = resolve(n.url, "image");
+        } else if (n.type === "link" || n.type === "definition") {
+          if (typeof n.url === "string") n.url = resolve(n.url, "link");
+        }
+      });
+    };
+  };
+}
+function remarkResolveWikilinks(resolve) {
+  const WIKILINK_RE = /(?<!!)\[\[([^\]]+)\]\]/g;
+  return function attacher() {
+    return (tree) => {
+      visit5(tree, "text", (node, index, parent) => {
+        const n = node;
+        const p = parent;
+        if (!p?.children || index == null || typeof n.value !== "string") return;
+        const text = n.value;
+        if (!text.includes("[[")) return;
+        const newChildren = [];
+        let lastIndex = 0;
+        WIKILINK_RE.lastIndex = 0;
+        let match;
+        while ((match = WIKILINK_RE.exec(text)) !== null) {
+          if (match.index > lastIndex) {
+            newChildren.push({ type: "text", value: text.slice(lastIndex, match.index) });
+          }
+          const inner = match[1];
+          const pipeIdx = inner.indexOf("|");
+          const targetPart = pipeIdx !== -1 ? inner.slice(0, pipeIdx) : inner;
+          const alias = pipeIdx !== -1 ? inner.slice(pipeIdx + 1) : void 0;
+          const hashIdx = targetPart.indexOf("#");
+          const target = hashIdx !== -1 ? targetPart.slice(0, hashIdx) : targetPart;
+          const anchor = hashIdx !== -1 ? targetPart.slice(hashIdx + 1) : void 0;
+          const opts = anchor ? { anchor } : {};
+          const href = resolve(target.trim(), opts);
+          const linkText = alias?.trim() || target.trim();
+          if (href === null) {
+            newChildren.push({ type: "text", value: match[0] });
+          } else {
+            newChildren.push({
+              type: "link",
+              url: href,
+              title: null,
+              children: [{ type: "text", value: linkText }]
+            });
+          }
+          lastIndex = match.index + match[0].length;
+        }
+        if (lastIndex < text.length) {
+          newChildren.push({ type: "text", value: text.slice(lastIndex) });
+        }
+        if (newChildren.length > 0) {
+          p.children.splice(index, 1, ...newChildren);
+          return index + newChildren.length;
+        }
+      });
+    };
+  };
+}
+function remarkResolveTransclusions() {
+  const STANDALONE_RE = /^!\[\[([^\]]+)\]\]$/;
+  return function attacher() {
+    return (tree) => {
+      visit5(tree, "paragraph", (node) => {
+        const n = node;
+        if (!n.children || n.children.length !== 1) return;
+        const child = n.children[0];
+        if (child.type !== "text" || typeof child.value !== "string") return;
+        const match = child.value.trim().match(STANDALONE_RE);
+        if (!match) return;
+        const inner = match[1];
+        const hashIdx = inner.indexOf("#");
+        const target = (hashIdx !== -1 ? inner.slice(0, hashIdx) : inner).trim();
+        const section = hashIdx !== -1 ? inner.slice(hashIdx + 1).trim() : void 0;
+        const payload = section ? { target, section } : { target };
+        const data = n.data ?? (n.data = {});
+        data.hName = BRAND_TRANSCLUSION_TAG;
+        data.hProperties = { [BRAND_TRANSCLUSION_PROP]: JSON.stringify(payload) };
+        n.children = [];
+      });
+    };
+  };
+}
+function nestedItemContains(node, line) {
+  const kids = node?.children ?? [];
+  for (const kid of kids) {
+    const el = kid;
+    if (el.tagName === "li") {
+      const pos = getSourcePos(kid);
+      if (pos && line >= pos.start && line <= pos.end) return true;
+    }
+    if (nestedItemContains(kid, line)) return true;
+  }
+  return false;
+}
+function getSourcePos(node) {
+  const pos = node?.position;
+  if (typeof pos?.start?.line !== "number") return void 0;
+  return { start: pos.start.line, end: pos.end?.line ?? pos.start.line };
+}
+function RemovedMarker({ count }) {
+  return /* @__PURE__ */ jsxs10(
+    "div",
+    {
+      role: "note",
+      "aria-label": `${count} ${count === 1 ? "line" : "lines"} removed here`,
+      className: "flex items-center gap-2 text-meta text-destructive-text",
+      children: [
+        /* @__PURE__ */ jsx12("span", { "aria-hidden": "true", className: "font-mono", children: "\u2212" }),
+        /* @__PURE__ */ jsx12("span", { "aria-hidden": "true", className: "flex-1 border-t border-dashed border-destructive/40" }),
+        /* @__PURE__ */ jsxs10("span", { children: [
+          count,
+          " ",
+          count === 1 ? "line" : "lines",
+          " removed"
+        ] }),
+        /* @__PURE__ */ jsx12("span", { "aria-hidden": "true", className: "flex-1 border-t border-dashed border-destructive/40" })
+      ]
+    }
+  );
+}
+function annotated(render, searchWash = true) {
+  return function AnnotatedBlock(props) {
+    const annotations = useContext4(AnnotationsContext);
+    const search = useContext4(SearchContext);
+    const pos = getSourcePos(props.node);
+    const enriched = pos ? { ...props, "data-sourcepos": `${pos.start}:${pos.end}` } : props;
+    const wash = pos && annotations.length > 0 ? annotationForRange(annotations, pos.start, pos.end) : void 0;
+    const removed = pos && annotations.length > 0 ? removedMarkerAt(annotations, pos.start) : void 0;
+    const activeSearch = searchWash && pos != null && search.activeLine != null && search.activeLine >= pos.start && search.activeLine <= pos.end;
+    let content = render(enriched);
+    if (!wash && !removed && !activeSearch) return content;
+    if (wash) {
+      content = /* @__PURE__ */ jsx12(
+        "div",
+        {
+          "data-annotation": wash.kind,
+          className: "border-s-2 border-s-success bg-success/10 py-1.5 pe-2 ps-3",
+          children: content
+        }
+      );
+    }
+    if (activeSearch) {
+      content = /* @__PURE__ */ jsx12("div", { "data-search-active": "", className: "-mx-2 rounded-md bg-primary/10 px-2 py-1", children: content });
+    }
+    return /* @__PURE__ */ jsxs10(Fragment2, { children: [
+      removed ? /* @__PURE__ */ jsx12(RemovedMarker, { count: removed.removedCount ?? 1 }) : null,
+      content
+    ] });
+  };
+}
+function heading(level) {
+  return function HeadingMd({ node: _n, children, ...rest }) {
+    const headingActions = useContext4(HeadingActionsContext);
+    const start = rest["data-sourcepos"]?.split(":")[0];
+    const line = start ? Number(start) : void 0;
+    const headingId = useHeadingId(line);
+    const slot = headingActions?.({
+      level,
+      text: flattenNodeText(children),
+      line
+    });
+    return /* @__PURE__ */ jsxs10(
+      ProseHeading,
+      {
+        level,
+        id: headingId,
+        ...rest,
+        className: cn11(
+          slot ? "group/heading" : void 0,
+          headingId ? "scroll-mt-4" : void 0,
+          rest.className
+        ),
+        children: [
+          children,
+          slot ? /* @__PURE__ */ jsx12(
+            "span",
+            {
+              className: "ms-1.5 inline-flex align-middle opacity-0 transition-opacity duration-fast ease-standard focus-within:opacity-100 group-hover/heading:opacity-100 has-[[aria-pressed=true]]:opacity-100 motion-reduce:transition-none",
+              children: slot
+            }
+          ) : null
+        ]
+      }
+    );
+  };
+}
+var CALLOUT_VARIANT = {
+  info: "info",
+  note: "info",
+  tip: "success",
+  success: "success",
+  warning: "warning",
+  caution: "warning",
+  danger: "destructive",
+  error: "destructive",
+  destructive: "destructive"
+};
+var TIMELINE_STATUS = {
+  done: "done",
+  complete: "done",
+  completed: "done",
+  active: "active",
+  current: "active",
+  pending: "pending",
+  todo: "pending"
+};
+function UnknownBlock({ name }) {
+  return /* @__PURE__ */ jsxs10(Alert, { variant: "destructive", children: [
+    /* @__PURE__ */ jsxs10(AlertTitle, { children: [
+      "Unknown block: ",
+      name
+    ] }),
+    /* @__PURE__ */ jsxs10(AlertDescription, { children: [
+      "No renderer is mapped for ",
+      /* @__PURE__ */ jsxs10("code", { children: [
+        ":::",
+        name
+      ] }),
+      ". Add it to the brand directive registry, or fix the directive name."
+    ] })
+  ] });
+}
+function readDirectivePayload(rest) {
+  const raw = rest[BRAND_DIRECTIVE_ATTR] ?? rest.dataBrand;
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return "malformed";
+  }
+}
+function BrandDirective({ node: _n, children, ...rest }) {
+  const registry = useContext4(RegistryContext);
+  const payload = readDirectivePayload(rest);
+  if (payload === null) return null;
+  if (payload === "malformed") return /* @__PURE__ */ jsx12(UnknownBlock, { name: "malformed" });
+  if (!payload.known) return /* @__PURE__ */ jsx12(UnknownBlock, { name: payload.name });
+  const attrs = payload.attributes ?? {};
+  switch (payload.name) {
+    case "card":
+      return /* @__PURE__ */ jsxs10(Card, { children: [
+        attrs.title ? /* @__PURE__ */ jsx12(CardHeader, { children: /* @__PURE__ */ jsx12(CardTitle, { children: attrs.title }) }) : null,
+        /* @__PURE__ */ jsx12(CardContent, { className: cn11(!attrs.title && "pt-6"), children })
+      ] });
+    case "callout":
+      return /* @__PURE__ */ jsxs10(Alert, { variant: CALLOUT_VARIANT[attrs.type ?? ""] ?? "default", children: [
+        attrs.title ? /* @__PURE__ */ jsx12("div", { className: "mb-1 font-medium leading-none tracking-tight", children: attrs.title }) : null,
+        /* @__PURE__ */ jsx12(AlertDescription, { children })
+      ] });
+    case "metric":
+      return /* @__PURE__ */ jsx12(
+        MetricBlock,
+        {
+          label: attrs.label ?? "",
+          value: attrs.value ?? "",
+          description: attrs.description,
+          delta: attrs.delta,
+          deltaDirection: attrs.delta?.startsWith("+") ? "up" : attrs.delta?.startsWith("-") ? "down" : "neutral"
+        }
+      );
+    case "timeline":
+      return /* @__PURE__ */ jsx12(
+        Timeline,
+        {
+          items: (payload.items ?? []).map((it) => ({
+            title: it.title,
+            status: TIMELINE_STATUS[it.status] ?? "pending"
+          }))
+        }
+      );
+    default: {
+      const renderer = registry.directives.get(payload.name);
+      if (renderer && (!renderer.kinds || renderer.kinds.includes(payload.kind))) {
+        return /* @__PURE__ */ jsx12(Fragment2, { children: renderer.render({
+          name: payload.name,
+          kind: payload.kind,
+          attributes: attrs,
+          children,
+          textValue: payload.label,
+          rawBody: payload.body
+        }) });
+      }
+      return /* @__PURE__ */ jsx12(UnknownBlock, { name: payload.name });
+    }
+  }
+}
+function BrandInlineDirective({ node: _n, children, ...rest }) {
+  const registry = useContext4(RegistryContext);
+  const payload = readDirectivePayload(rest);
+  if (payload === null || payload === "malformed") return /* @__PURE__ */ jsx12(Fragment2, { children });
+  const renderer = registry.directives.get(payload.name);
+  if (!renderer || renderer.kinds && !renderer.kinds.includes("inline")) {
+    return /* @__PURE__ */ jsx12(Fragment2, { children });
+  }
+  return /* @__PURE__ */ jsx12(Fragment2, { children: renderer.render({
+    name: payload.name,
+    kind: "inline",
+    attributes: payload.attributes ?? {},
+    children,
+    textValue: payload.label
+  }) });
+}
+function fenceText(children) {
+  if (typeof children === "string") return children;
+  if (Array.isArray(children)) return children.map((c) => fenceText(c)).join("");
+  return "";
+}
+function isMermaidCodeElement(child) {
+  return isValidElement(child) && /\blanguage-mermaid\b/.test(child.props?.className ?? "");
+}
+function PreBlock({ node, children, ...rest }) {
+  const search = useContext4(SearchContext);
+  const registry = useContext4(RegistryContext);
+  const pos = getSourcePos(node);
+  const activeInBlock = pos != null && search.activeLine != null && search.activeLine >= pos.start && search.activeLine <= pos.end;
+  const list = Array.isArray(children) ? children : [children];
+  const mermaidChild = list.find(isMermaidCodeElement);
+  if (mermaidChild) {
+    const chart = fenceText(mermaidChild.props.children).replace(
+      /\n$/,
+      ""
+    );
+    return /* @__PURE__ */ jsx12(
+      MermaidDiagram,
+      {
+        chart,
+        "data-sourcepos": pos ? `${pos.start}:${pos.end}` : void 0,
+        highlightTerm: search.term,
+        activeText: activeInBlock && search.activeLine != null ? search.lines[search.activeLine - 1] : void 0
+      }
+    );
+  }
+  const codeEl = list.find(isValidElement);
+  const fenceLang = fenceLanguage(codeEl?.props.className);
+  const fenceRenderer = fenceLang ? registry.fences.get(fenceLang) : void 0;
+  if (fenceLang && fenceRenderer && codeEl) {
+    const source = fenceText(codeEl.props.children).replace(/\n$/, "");
+    const rendered = fenceRenderer.render({ source, lang: fenceLang });
+    return pos ? /* @__PURE__ */ jsx12("div", { "data-sourcepos": `${pos.start}:${pos.end}`, children: rendered }) : /* @__PURE__ */ jsx12(Fragment2, { children: rendered });
+  }
+  const codeText = fenceText(codeEl ? codeEl.props.children : children).replace(
+    /\n$/,
+    ""
+  );
+  return /* @__PURE__ */ jsx12(
+    CodeFence,
+    {
+      ...rest,
+      codeText,
+      language: fenceLang,
+      searchActive: activeInBlock,
+      children
+    }
+  );
+}
+function ImageMd({ node: _n, src, alt, ...rest }) {
+  return /* @__PURE__ */ jsx12(
+    "img",
+    {
+      src,
+      alt: alt ?? "",
+      loading: "lazy",
+      className: "max-w-full rounded-md border border-border",
+      ...rest
+    }
+  );
+}
+function LinkMd({ node: _n, href, children, ...rest }) {
+  const renderLinkPreview = useContext4(LinkPreviewContext);
+  const anchor = /* @__PURE__ */ jsx12(ProseLink, { href, ...rest, children });
+  if (renderLinkPreview && typeof href === "string") {
+    return /* @__PURE__ */ jsx12(Fragment2, { children: renderLinkPreview(href, anchor) });
+  }
+  return anchor;
+}
+function TransclusionBlock({ node: _n, ...rest }) {
+  const resolveTransclusion = useContext4(TransclusionResolverContext);
+  const depth = useContext4(TransclusionDepthContext);
+  const linkPreview = useContext4(LinkPreviewContext);
+  const rawAttr = rest[BRAND_TRANSCLUSION_ATTR] ?? rest.dataTransclusion;
+  if (!rawAttr || !resolveTransclusion) {
+    return /* @__PURE__ */ jsx12("span", { children: rawAttr ? `![[${JSON.parse(rawAttr).target}]]` : null });
+  }
+  let payload;
+  try {
+    payload = JSON.parse(rawAttr);
+  } catch {
+    return null;
+  }
+  const { target, section } = payload;
+  const label = section ? `${target}#${section}` : target;
+  if (depth >= TRANSCLUSION_MAX_DEPTH) {
+    return /* @__PURE__ */ jsxs10(
+      "figure",
+      {
+        "aria-label": `Embedded: ${label}`,
+        className: "my-3 rounded-md border-s-2 border-s-muted bg-muted/40 px-4 py-3",
+        "data-testid": "transclusion-block",
+        "data-transclusion-depth": depth,
+        children: [
+          /* @__PURE__ */ jsx12("figcaption", { className: "mb-1 text-meta text-muted-foreground", children: label }),
+          /* @__PURE__ */ jsx12("p", { className: "text-meta text-muted-foreground italic", children: "Transclusion too deep \u2014 embed skipped." })
+        ]
+      }
+    );
+  }
+  const content = resolveTransclusion(target, section ? { section } : {});
+  if (content === null) {
+    return /* @__PURE__ */ jsx12("span", { children: `![[${label}]]` });
+  }
+  return /* @__PURE__ */ jsx12(TransclusionDepthContext.Provider, { value: depth + 1, children: /* @__PURE__ */ jsx12(LinkPreviewContext.Provider, { value: linkPreview, children: /* @__PURE__ */ jsx12(RecursiveTransclusionContent, { target, label, content }) }) });
+}
+function RecursiveTransclusionContent({
+  target: _target,
+  label,
+  content
+}) {
+  const plugins = useMemo5(() => {
+    return [...baseRemarkPlugins, ...buildMarkdownPlugins()];
+  }, []);
+  return /* @__PURE__ */ jsxs10(
+    "figure",
+    {
+      "aria-label": `Embedded: ${label}`,
+      className: "my-3 rounded-md border-s-2 border-s-muted bg-muted/40 px-4 py-2",
+      "data-testid": "transclusion-block",
+      children: [
+        /* @__PURE__ */ jsx12("figcaption", { className: "mb-1.5 text-meta text-muted-foreground", children: label }),
+        /* @__PURE__ */ jsx12("div", { className: "text-body text-foreground", children: /* @__PURE__ */ jsx12(
+          Streamdown,
+          {
+            parseMarkdownIntoBlocksFn: singleBlock,
+            remarkPlugins: plugins,
+            rehypePlugins,
+            allowedTags,
+            components,
+            children: content
+          }
+        ) })
+      ]
+    }
+  );
+}
+var components = {
+  h1: annotated(heading(1)),
+  h2: annotated(heading(2)),
+  h3: annotated(heading(3)),
+  h4: annotated(heading(4)),
+  h5: annotated(heading(5)),
+  h6: annotated(heading(6)),
+  p: annotated(({ node: _n, ...p }) => /* @__PURE__ */ jsx12(ProseText, { ...p })),
+  a: LinkMd,
+  img: ImageMd,
+  // Lists wash at ITEM granularity (a whole-list wash drowns the page), so the
+  // ul/ol wrappers opt out of the search wash and the li carries it inline
+  // (no wrapper div — that would break list semantics).
+  ul: annotated(
+    ({ node: _n, ...p }) => /* @__PURE__ */ jsx12(ProseList, { ...p }),
+    false
+  ),
+  ol: annotated(
+    ({ node: _n, ...p }) => /* @__PURE__ */ jsx12(ProseList, { ordered: true, ...p }),
+    false
+  ),
+  li: function ListItemMd({ node, ...p }) {
+    const search = useContext4(SearchContext);
+    const pos = getSourcePos(node);
+    const active = pos != null && search.activeLine != null && search.activeLine >= pos.start && search.activeLine <= pos.end && !nestedItemContains(node, search.activeLine);
+    return /* @__PURE__ */ jsx12(
+      ProseListItem,
+      {
+        "data-sourcepos": pos ? `${pos.start}:${pos.end}` : void 0,
+        "data-search-active": active ? "" : void 0,
+        ...p,
+        className: cn11(active && "-mx-1 rounded-sm bg-primary/10 px-1", p.className)
+      }
+    );
+  },
+  blockquote: annotated(({ node: _n, ...p }) => /* @__PURE__ */ jsx12(ProseBlockquote, { ...p })),
+  hr: annotated(() => /* @__PURE__ */ jsx12(Separator3, { className: "my-4" })),
+  pre: annotated(PreBlock, false),
+  table: annotated(({ node: _n, ...p }) => /* @__PURE__ */ jsx12(Table, { ...p })),
+  thead: ({ node: _n, ...p }) => /* @__PURE__ */ jsx12(TableHeader, { ...p }),
+  tbody: ({ node: _n, ...p }) => /* @__PURE__ */ jsx12(TableBody, { ...p }),
+  tr: ({ node: _n, ...p }) => /* @__PURE__ */ jsx12(TableRow, { ...p }),
+  th: ({ node: _n, ...p }) => /* @__PURE__ */ jsx12(TableHead, { ...p }),
+  td: ({ node: _n, ...p }) => /* @__PURE__ */ jsx12(TableCell, { ...p }),
+  [BRAND_DIRECTIVE_TAG]: annotated(BrandDirective),
+  // Inline directives render un-`annotated` (no block wrapper) to stay in the text flow.
+  [BRAND_DIRECTIVE_INLINE_TAG]: BrandInlineDirective,
+  // Transclusion embeds (`![[target]]`) — resolved + recursively rendered by TransclusionBlock.
+  [BRAND_TRANSCLUSION_TAG]: TransclusionBlock,
+  // Academic layer — footnotes, math, citations (inline tags stay in the text flow;
+  // the footnote section is a generated block).
+  [FOOTNOTE_REF_TAG]: FootnoteRef,
+  [FOOTNOTE_ITEM_TAG]: FootnoteItem,
+  [FOOTNOTE_LIST_TAG]: ({ node: _n, children, ...rest }) => /* @__PURE__ */ jsx12(FootnoteList, { ...rest, children }),
+  [MATH_INLINE_TAG]: MathInlineTag,
+  [MATH_BLOCK_TAG]: MathBlockTag,
+  [CITE_TAG]: InlineCite
+};
+var MarkdownPreview = forwardRef7(
+  function MarkdownPreview2({
+    children,
+    stripFrontmatter = true,
+    annotations,
+    resolveUrl,
+    searchTerm,
+    activeSearchLine,
+    headingActions,
+    evaluate,
+    extensions,
+    resolveWikilink,
+    resolveTransclusion,
+    renderLinkPreview,
+    footnotes,
+    math,
+    resolveCitation,
+    citationStyle = "numeric",
+    toc,
+    evaluateIteration,
+    interpolate,
+    className,
+    ...props
+  }, ref) {
+    const markdown = stripFrontmatter ? parseFrontmatter(children).content : children;
+    const fmOffset = stripFrontmatter ? children.split("\n").length - markdown.split("\n").length : 0;
+    const shifted = useMemo5(() => {
+      if (!annotations?.length) return [];
+      return fmOffset ? shiftAnnotations(annotations, fmOffset) : annotations;
+    }, [annotations, fmOffset]);
+    const search = useMemo5(() => {
+      const term = searchTerm?.trim();
+      const activeLine = activeSearchLine != null && activeSearchLine - fmOffset >= 1 ? activeSearchLine - fmOffset : void 0;
+      return {
+        term: term && term.length >= 2 ? term : void 0,
+        activeLine,
+        lines: markdown.split("\n")
+      };
+    }, [searchTerm, activeSearchLine, fmOffset, markdown]);
+    const citations = useMemo5(() => {
+      if (!resolveCitation) return null;
+      return collectCitations(markdown, resolveCitation);
+    }, [markdown, resolveCitation]);
+    const outline = useMemo5(() => toc ? parseMarkdownOutline(markdown) : null, [toc, markdown]);
+    const registry = useMemo5(() => {
+      const directives = /* @__PURE__ */ new Map();
+      for (const d of extensions?.directives ?? []) directives.set(d.name, d);
+      const fences = /* @__PURE__ */ new Map();
+      for (const f of extensions?.fences ?? []) fences.set(f.lang, f);
+      if (toc) {
+        directives.set("toc", {
+          name: "toc",
+          kinds: ["leaf", "container"],
+          render: ({ attributes }) => /* @__PURE__ */ jsx12(TableOfContents, { title: attributes.title || void 0 })
+        });
+      }
+      if (resolveCitation) {
+        const renderBibliography = ({ attributes }) => /* @__PURE__ */ jsx12(Bibliography, { title: attributes.title || void 0 });
+        directives.set("bibliography", {
+          name: "bibliography",
+          kinds: ["leaf", "container"],
+          render: renderBibliography
+        });
+        directives.set("references", {
+          name: "references",
+          kinds: ["leaf", "container"],
+          render: renderBibliography
+        });
+      }
+      if (evaluateIteration) {
+        const iterationDirective = (name) => ({
+          name,
+          kinds: ["container"],
+          render: ({ attributes, rawBody }) => /* @__PURE__ */ jsx12(
+            IterationDirective,
+            {
+              spec: specFromDirective(name, attributes, rawBody),
+              evaluate: evaluateIteration,
+              interpolate,
+              renderCell: (md) => /* @__PURE__ */ jsx12(
+                IterationCell,
+                {
+                  markdown: md,
+                  config: {
+                    evaluateIteration,
+                    interpolate,
+                    evaluate,
+                    extensions,
+                    footnotes,
+                    math,
+                    resolveCitation,
+                    citationStyle
+                  }
+                }
+              )
+            }
+          )
+        });
+        directives.set("iterate", iterationDirective("iterate"));
+        directives.set("pivot", iterationDirective("pivot"));
+      }
+      if (evaluate && !fences.has("calc")) {
+        fences.set("calc", {
+          lang: "calc",
+          render: ({ source }) => /* @__PURE__ */ jsx12(CalcBlock, { source, evaluate })
+        });
+      }
+      if (evaluate && !directives.has("calc")) {
+        directives.set("calc", {
+          name: "calc",
+          kinds: ["inline"],
+          // `textValue` is the verbatim expression (markdown chars preserved);
+          // fall back to the rendered label only if positions were unavailable.
+          render: ({ textValue, children: children2 }) => /* @__PURE__ */ jsx12(CalcInline, { source: textValue ?? flattenNodeText(children2), evaluate })
+        });
+      }
+      return { directives, fences };
+    }, [
+      extensions,
+      evaluate,
+      toc,
+      resolveCitation,
+      citationStyle,
+      evaluateIteration,
+      interpolate,
+      footnotes,
+      math
+    ]);
+    const directiveNamesKey = [
+      ...(extensions?.directives ?? []).map((d) => d.name),
+      ...evaluate ? ["calc"] : [],
+      ...toc ? ["toc"] : [],
+      ...resolveCitation ? ["bibliography", "references"] : [],
+      ...evaluateIteration ? ["iterate", "pivot"] : []
+    ].join(" ");
+    const plugins = useMemo5(() => {
+      const directiveNames = directiveNamesKey ? directiveNamesKey.split(" ") : [];
+      const rawBodyNames = evaluateIteration ? ["iterate", "pivot"] : [];
+      let list = [
+        ...baseRemarkPlugins,
+        ...buildMarkdownPlugins({ directiveNames, rawBodyNames })
+      ];
+      if (math) list = [...list, remarkMath, remarkBrandMath];
+      if (footnotes) list = [...list, remarkBrandFootnotes];
+      if (resolveCitation) list = [...list, remarkBrandCitations];
+      if (resolveWikilink) list = [...list, remarkResolveWikilinks(resolveWikilink)];
+      if (resolveTransclusion) list = [...list, remarkResolveTransclusions()];
+      if (resolveUrl) list = [...list, remarkResolveUrls(resolveUrl)];
+      return list;
+    }, [
+      resolveUrl,
+      resolveWikilink,
+      resolveTransclusion,
+      directiveNamesKey,
+      math,
+      footnotes,
+      resolveCitation,
+      evaluateIteration
+    ]);
+    const streamdown = /* @__PURE__ */ jsx12(
+      Streamdown,
+      {
+        parseMarkdownIntoBlocksFn: singleBlock,
+        remarkPlugins: plugins,
+        rehypePlugins,
+        allowedTags,
+        components,
+        children: markdown
+      }
+    );
+    const withCitations = citations ? /* @__PURE__ */ jsx12(CitationProvider, { order: citations.order, byKey: citations.byKey, style: citationStyle, children: streamdown }) : streamdown;
+    const body = outline ? /* @__PURE__ */ jsx12(TocProvider, { items: outline, children: withCitations }) : withCitations;
+    return /* @__PURE__ */ jsx12(
+      "div",
+      {
+        ref,
+        "data-testid": "markdown-preview",
+        className: cn11(
+          "text-body text-foreground [&_pre]:my-3",
+          "[&_h1]:!mt-10 [&_h2]:!mt-9 [&_h3]:!mt-7 [&_h4]:!mt-6",
+          "[&_:is(h1,h2,h3,h4)+*]:!mt-3 [&_:is(h1,h2,h3,h4):first-child]:!mt-0",
+          className
+        ),
+        ...props,
+        children: /* @__PURE__ */ jsx12(AnnotationsContext.Provider, { value: shifted, children: /* @__PURE__ */ jsx12(SearchContext.Provider, { value: search, children: /* @__PURE__ */ jsx12(HeadingActionsContext.Provider, { value: headingActions ?? null, children: /* @__PURE__ */ jsx12(RegistryContext.Provider, { value: registry, children: /* @__PURE__ */ jsx12(LinkPreviewContext.Provider, { value: renderLinkPreview ?? null, children: /* @__PURE__ */ jsx12(TransclusionResolverContext.Provider, { value: resolveTransclusion ?? null, children: /* @__PURE__ */ jsx12(TransclusionDepthContext.Provider, { value: 0, children: body }) }) }) }) }) }) })
+      }
+    );
+  }
+);
+function IterationCell({ markdown, config }) {
+  return /* @__PURE__ */ jsx12(MarkdownPreview, { stripFrontmatter: false, ...config, children: markdown });
+}
+
+// src/markdown-toolbar/markdown-toolbar.tsx
+import {
+  Button as Button3,
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuLabel,
+  DropdownMenuSeparator,
+  DropdownMenuTrigger,
+  Separator as Separator4,
+  Tooltip,
+  TooltipContent,
+  TooltipProvider,
+  TooltipTrigger
+} from "@elabs-ai/components-ui";
+import { cn as cn12 } from "@elabs-ai/components-ui/lib/cn";
+import {
+  Bold,
+  ChevronDown,
+  Code2,
+  Heading,
+  Italic,
+  Link2,
+  List,
+  ListOrdered,
+  Minus as Minus2,
+  Quote,
+  SquarePlus
+} from "lucide-react";
+import { forwardRef as forwardRef8, Fragment as Fragment3 } from "react";
+import { jsx as jsx13, jsxs as jsxs11 } from "react/jsx-runtime";
+var DIRECTIVE_SNIPPETS = [
+  { label: "Card", snippet: `:::card{title="Title"}
+Content
+:::` },
+  { label: "Callout", snippet: `:::callout{type="info" title="Note"}
+Message
+:::` },
+  { label: "Metric", snippet: `::metric{label="Label" value="0" description="detail"}` },
+  {
+    label: "Timeline",
+    snippet: `:::timeline
+- (done) Step one
+- (active) Step two
+- (pending) Step three
+:::`
+  }
+];
+var MarkdownToolbar = forwardRef8(
+  function MarkdownToolbar2({ editor: editor2, actions, insertCommands, className, ...props }, ref) {
+    const disabled = !editor2;
+    const run = (fn) => () => {
+      if (editor2) fn(editor2);
+    };
+    const insertGroups = insertCommands ? groupSlashCommands(
+      insertCommands.filter((c) => typeof c.snippet === "string")
+    ) : null;
+    const IconButton = ({
+      label,
+      icon,
+      onClick
+    }) => /* @__PURE__ */ jsxs11(Tooltip, { children: [
+      /* @__PURE__ */ jsx13(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsx13(
+        Button3,
+        {
+          type: "button",
+          variant: "ghost",
+          size: "icon-sm",
+          disabled,
+          onClick,
+          "aria-label": label,
+          children: icon
+        }
+      ) }),
+      /* @__PURE__ */ jsx13(TooltipContent, { children: label })
+    ] });
+    return /* @__PURE__ */ jsx13(TooltipProvider, { delayDuration: 300, children: /* @__PURE__ */ jsxs11(
+      "div",
+      {
+        ref,
+        role: "toolbar",
+        "aria-label": "Markdown formatting",
+        className: cn12(
+          "flex h-10 shrink-0 items-center gap-0.5 border-b border-border bg-surface px-2",
+          className
+        ),
+        ...props,
+        children: [
+          /* @__PURE__ */ jsx13(
+            IconButton,
+            {
+              label: "Bold",
+              icon: /* @__PURE__ */ jsx13(Bold, { className: "size-4" }),
+              onClick: run((e) => wrapSelection(e, "**"))
+            }
+          ),
+          /* @__PURE__ */ jsx13(
+            IconButton,
+            {
+              label: "Italic",
+              icon: /* @__PURE__ */ jsx13(Italic, { className: "size-4" }),
+              onClick: run((e) => wrapSelection(e, "*"))
+            }
+          ),
+          /* @__PURE__ */ jsx13(
+            IconButton,
+            {
+              label: "Inline code",
+              icon: /* @__PURE__ */ jsx13(Code2, { className: "size-4" }),
+              onClick: run((e) => wrapSelection(e, "`"))
+            }
+          ),
+          /* @__PURE__ */ jsx13(IconButton, { label: "Link", icon: /* @__PURE__ */ jsx13(Link2, { className: "size-4" }), onClick: run(insertLink) }),
+          /* @__PURE__ */ jsx13(Separator4, { orientation: "vertical", className: "mx-1 h-5" }),
+          /* @__PURE__ */ jsxs11(DropdownMenu, { children: [
+            /* @__PURE__ */ jsxs11(Tooltip, { children: [
+              /* @__PURE__ */ jsx13(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsx13(DropdownMenuTrigger, { asChild: true, children: /* @__PURE__ */ jsxs11(
+                Button3,
+                {
+                  type: "button",
+                  variant: "ghost",
+                  size: "sm",
+                  disabled,
+                  className: "gap-1",
+                  "aria-label": "Heading level",
+                  children: [
+                    /* @__PURE__ */ jsx13(Heading, { className: "size-4" }),
+                    /* @__PURE__ */ jsx13(ChevronDown, { className: "size-3" })
+                  ]
+                }
+              ) }) }),
+              /* @__PURE__ */ jsx13(TooltipContent, { children: "Heading" })
+            ] }),
+            /* @__PURE__ */ jsx13(DropdownMenuContent, { align: "start", children: [1, 2, 3].map((level) => /* @__PURE__ */ jsxs11(
+              DropdownMenuItem,
+              {
+                onSelect: run((e) => toggleLinePrefix(e, `${"#".repeat(level)} `)),
+                children: [
+                  "Heading ",
+                  level
+                ]
+              },
+              level
+            )) })
+          ] }),
+          /* @__PURE__ */ jsx13(
+            IconButton,
+            {
+              label: "Quote",
+              icon: /* @__PURE__ */ jsx13(Quote, { className: "size-4" }),
+              onClick: run((e) => toggleLinePrefix(e, "> "))
+            }
+          ),
+          /* @__PURE__ */ jsx13(
+            IconButton,
+            {
+              label: "Bullet list",
+              icon: /* @__PURE__ */ jsx13(List, { className: "size-4" }),
+              onClick: run((e) => toggleLinePrefix(e, "- "))
+            }
+          ),
+          /* @__PURE__ */ jsx13(
+            IconButton,
+            {
+              label: "Numbered list",
+              icon: /* @__PURE__ */ jsx13(ListOrdered, { className: "size-4" }),
+              onClick: run((e) => toggleLinePrefix(e, "1. "))
+            }
+          ),
+          /* @__PURE__ */ jsx13(
+            IconButton,
+            {
+              label: "Divider",
+              icon: /* @__PURE__ */ jsx13(Minus2, { className: "size-4" }),
+              onClick: run(insertHorizontalRule)
+            }
+          ),
+          /* @__PURE__ */ jsx13(Separator4, { orientation: "vertical", className: "mx-1 h-5" }),
+          /* @__PURE__ */ jsxs11(DropdownMenu, { children: [
+            /* @__PURE__ */ jsxs11(Tooltip, { children: [
+              /* @__PURE__ */ jsx13(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsx13(DropdownMenuTrigger, { asChild: true, children: /* @__PURE__ */ jsxs11(
+                Button3,
+                {
+                  type: "button",
+                  variant: "ghost",
+                  size: "sm",
+                  disabled,
+                  className: "gap-1",
+                  "aria-label": "Insert block",
+                  children: [
+                    /* @__PURE__ */ jsx13(SquarePlus, { className: "size-4" }),
+                    /* @__PURE__ */ jsx13("span", { className: "text-xs", children: "Insert" })
+                  ]
+                }
+              ) }) }),
+              /* @__PURE__ */ jsx13(TooltipContent, { children: "Insert brand block" })
+            ] }),
+            /* @__PURE__ */ jsx13(DropdownMenuContent, { align: "start", children: insertGroups && insertGroups.length > 0 ? insertGroups.map(({ group, commands }, gi) => /* @__PURE__ */ jsxs11(Fragment3, { children: [
+              gi > 0 ? /* @__PURE__ */ jsx13(DropdownMenuSeparator, {}) : null,
+              /* @__PURE__ */ jsx13(DropdownMenuLabel, { className: "text-meta font-medium text-muted-foreground", children: group }),
+              commands.map((cmd) => /* @__PURE__ */ jsxs11(
+                DropdownMenuItem,
+                {
+                  className: "gap-2",
+                  onSelect: run((e) => insertDirective(e, cmd.snippet)),
+                  children: [
+                    cmd.icon ? /* @__PURE__ */ jsx13("span", { className: "flex size-4 shrink-0 items-center justify-center text-muted-foreground [&_svg]:size-4", children: cmd.icon }) : null,
+                    cmd.label
+                  ]
+                },
+                cmd.id
+              ))
+            ] }, group)) : DIRECTIVE_SNIPPETS.map(({ label, snippet }) => /* @__PURE__ */ jsx13(
+              DropdownMenuItem,
+              {
+                onSelect: run((e) => insertDirective(e, snippet)),
+                children: label
+              },
+              label
+            )) })
+          ] }),
+          actions ? /* @__PURE__ */ jsx13("div", { className: "ml-auto flex items-center gap-1.5", children: actions }) : null
+        ]
+      }
+    ) });
+  }
+);
+
+// src/markdown-workspace/focus-writing.ts
+function topLevelBlockOf(editorRoot, node) {
+  let current = node;
+  while (current && current.parentNode !== editorRoot) {
+    current = current.parentNode;
+  }
+  return current instanceof Element ? current : null;
+}
+function typewriterDelta(caretTop, caretHeight, hostTop, hostHeight, band = 0.22) {
+  if (hostHeight <= 0) return 0;
+  const center = hostTop + hostHeight / 2;
+  const caretMid = caretTop + caretHeight / 2;
+  const tolerance = hostHeight * band / 2;
+  const off = caretMid - center;
+  return Math.abs(off) <= tolerance ? 0 : off;
+}
+
+// src/markdown-workspace/markdown-workspace.tsx
+import { Fragment as Fragment4, jsx as jsx14, jsxs as jsxs12 } from "react/jsx-runtime";
+var MODES = [
+  { value: "source", label: "Source", icon: SquareCode },
+  { value: "split", label: "Split", icon: Columns2 },
+  { value: "wysiwyg", label: "Preview-edit", icon: Eye }
+];
+var MarkdownWorkspace = forwardRef9(
+  function MarkdownWorkspace2({
+    value,
+    defaultValue,
+    onChange,
+    mode,
+    defaultMode = "split",
+    onModeChange,
+    defaultFocusWriting = false,
+    focusWriting,
+    modeSwitch = true,
+    toolbarActions,
+    slashMenu = true,
+    insertCommands,
+    calc,
+    completions,
+    onEmbedAsset,
+    className,
+    ...props
+  }, ref) {
+    const slashCommandList = typeof slashMenu === "object" && slashMenu.commands ? slashMenu.commands : BRAND_SLASH_COMMANDS;
+    const toolbarInsertCommands = insertCommands ?? slashCommandList;
+    const isControlled = value !== void 0;
+    const [internalValue, setInternalValue] = useState5(value ?? defaultValue ?? "");
+    const markdown = isControlled ? value : internalValue;
+    const [internalMode, setInternalMode] = useState5(defaultMode);
+    const activeMode = mode ?? internalMode;
+    const [monaco5, setMonaco] = useState5(null);
+    const [selectionListeners] = useState5(() => /* @__PURE__ */ new Set());
+    const calcRef = useRef5(calc);
+    calcRef.current = calc;
+    const calcEnabled = calc != null;
+    useEffect5(() => {
+      if (!monaco5 || !calcEnabled) return;
+      monaco5.updateOptions({
+        quickSuggestions: { other: true, comments: false, strings: false }
+      });
+      return attachCalcMonaco(monaco5, () => calcRef.current);
+    }, [monaco5, calcEnabled]);
+    const completionsRef = useRef5(completions);
+    completionsRef.current = completions;
+    const completionsEnabled = completions != null;
+    useEffect5(() => {
+      if (!monaco5 || !completionsEnabled) return;
+      return attachCompletionsMonaco(monaco5, () => completionsRef.current);
+    }, [monaco5, completionsEnabled]);
+    useEffect5(() => {
+      if (activeMode === "wysiwyg") setMonaco(null);
+    }, [activeMode]);
+    const slashEnabled = slashMenu !== false;
+    const shortcut = typeof slashMenu === "object" && "shortcut" in slashMenu ? slashMenu.shortcut : DEFAULT_SLASH_SHORTCUT;
+    const [sourceSlashOpen, setSourceSlashOpen] = useState5(false);
+    const [typedTrigger, setTypedTrigger] = useState5(null);
+    const handleSourceSlashOpenChange = (next) => {
+      setSourceSlashOpen(next);
+      if (!next) setTypedTrigger(null);
+    };
+    useEffect5(() => {
+      if (!monaco5 || !slashEnabled) return;
+      const sub = monaco5.onDidChangeModelContent((e) => {
+        if (sourceSlashOpen || e.changes.length !== 1) return;
+        const change = e.changes[0];
+        if (!change || change.text !== "/") return;
+        const model = monaco5.getModel();
+        if (!model) return;
+        const line = change.range.startLineNumber;
+        const range = slashTriggerRange(line, model.getLineContent(line), change.range.startColumn);
+        if (!range) return;
+        setTypedTrigger(range);
+        setSourceSlashOpen(true);
+      });
+      return () => sub.dispose();
+    }, [monaco5, slashEnabled, sourceSlashOpen]);
+    const sourceCommands = useMemo6(
+      () => slashCommandList.filter((c) => c.snippet != null || typeof c.runInSource === "function"),
+      [slashCommandList]
+    );
+    const sourceActions = useMemo6(
+      () => slashEnabled && shortcut ? [
+        {
+          id: "brand.openSlashMenu",
+          label: "Insert block\u2026",
+          keybindings: [parseShortcut(shortcut)],
+          // Hotkey open inserts at the caret (no typed `/` to replace).
+          run: () => {
+            setTypedTrigger(null);
+            setSourceSlashOpen(true);
+          }
+        }
+      ] : [],
+      [slashEnabled, shortcut]
+    );
+    const previewPaneRef = useRef5(null);
+    const scrollLock = useRef5(null);
+    const lockTimer = useRef5(null);
+    const fmOffset = useMemo6(() => {
+      try {
+        const body = parseFrontmatter(markdown).content;
+        return markdown.split("\n").length - body.split("\n").length;
+      } catch {
+        return 0;
+      }
+    }, [markdown]);
+    const lock = (owner) => {
+      scrollLock.current = owner;
+      if (lockTimer.current) clearTimeout(lockTimer.current);
+      lockTimer.current = setTimeout(() => {
+        scrollLock.current = null;
+      }, 150);
+    };
+    useEffect5(() => {
+      if (!monaco5 || activeMode !== "split") return;
+      const disposable = monaco5.onDidScrollChange(() => {
+        if (scrollLock.current === "preview") return;
+        const range = monaco5.getVisibleRanges()[0];
+        const host = previewPaneRef.current;
+        if (!range || !host) return;
+        const line = range.startLineNumber - fmOffset;
+        let target = null;
+        for (const el of host.querySelectorAll("[data-sourcepos]")) {
+          const end = Number(el.dataset.sourcepos?.split(":")[1]);
+          if (end >= line) {
+            target = el;
+            break;
+          }
+        }
+        if (!target) return;
+        lock("editor");
+        host.scrollTop = target.getBoundingClientRect().top - host.getBoundingClientRect().top + host.scrollTop - 12;
+      });
+      return () => disposable.dispose();
+    }, [monaco5, activeMode, fmOffset]);
+    const onPreviewScroll = () => {
+      if (scrollLock.current === "editor" || !monaco5 || activeMode !== "split") return;
+      const host = previewPaneRef.current;
+      if (!host) return;
+      const hostTop = host.getBoundingClientRect().top;
+      for (const el of host.querySelectorAll("[data-sourcepos]")) {
+        if (el.getBoundingClientRect().bottom >= hostTop) {
+          const start = Number(el.dataset.sourcepos?.split(":")[0]);
+          if (!Number.isNaN(start)) {
+            lock("preview");
+            monaco5.setScrollTop(monaco5.getTopForLineNumber(Math.max(1, start + fmOffset)));
+          }
+          return;
+        }
+      }
+    };
+    const setMarkdown = (next) => {
+      if (!isControlled) setInternalValue(next);
+      onChange?.(next);
+    };
+    const wysiwygRef = useRef5(null);
+    const wysiwygBase = useRef5(null);
+    useEffect5(() => {
+      if (activeMode !== "wysiwyg") {
+        wysiwygBase.current = null;
+        return;
+      }
+      const original = markdown;
+      wysiwygBase.current = { original, baseline: null };
+      const poll = setInterval(() => {
+        const base = wysiwygBase.current;
+        if (!base || base.baseline !== null) {
+          clearInterval(poll);
+          return;
+        }
+        const s = wysiwygRef.current?.serialized();
+        if (s != null) {
+          base.baseline = s;
+          clearInterval(poll);
+        }
+      }, 50);
+      const stop = setTimeout(() => clearInterval(poll), 5e3);
+      return () => {
+        clearInterval(poll);
+        clearTimeout(stop);
+      };
+    }, [activeMode]);
+    const onWysiwygChange = (emitted) => {
+      const base = wysiwygBase.current;
+      const next = base && base.baseline !== null ? mergeNormalizedEdit(base.original, base.baseline, emitted) : emitted;
+      setMarkdown(next);
+    };
+    const focusWritingEnabled = focusWriting !== false;
+    const [focusWritingOn, setFocusWritingOn] = useState5(
+      focusWritingEnabled ? defaultFocusWriting : false
+    );
+    const wysiwygPaneRef = useRef5(null);
+    const lastInputAt = useRef5(0);
+    useEffect5(() => {
+      if (!(focusWritingEnabled && focusWritingOn && activeMode === "wysiwyg")) return;
+      const pane = wysiwygPaneRef.current;
+      if (!pane) return;
+      let active = null;
+      const onSelectionChange = () => {
+        const root = pane.querySelector(".ProseMirror");
+        if (!root) return;
+        const sel = document.getSelection();
+        const node = sel?.anchorNode ?? null;
+        if (!node || !root.contains(node)) return;
+        const block = topLevelBlockOf(root, node);
+        if (block !== active) {
+          active?.classList.remove("wb-fw-active");
+          block?.classList.add("wb-fw-active");
+          active = block;
+        }
+        if (Date.now() - lastInputAt.current < 200 && sel && sel.rangeCount > 0) {
+          const range = sel.getRangeAt(0).getBoundingClientRect();
+          const caret = range.height > 0 ? range : active?.getBoundingClientRect() ?? range;
+          const host = pane.getBoundingClientRect();
+          const delta = typewriterDelta(caret.top, caret.height, host.top, host.height);
+          if (delta !== 0) pane.scrollTop += delta;
+        }
+      };
+      const onInput = () => {
+        lastInputAt.current = Date.now();
+      };
+      document.addEventListener("selectionchange", onSelectionChange);
+      pane.addEventListener("input", onInput, true);
+      onSelectionChange();
+      return () => {
+        document.removeEventListener("selectionchange", onSelectionChange);
+        pane.removeEventListener("input", onInput, true);
+        active?.classList.remove("wb-fw-active");
+      };
+    }, [focusWritingEnabled, focusWritingOn, activeMode]);
+    const rootRef = useRef5(null);
+    useImperativeHandle(
+      ref,
+      () => {
+        const revealLine = (n, opts) => {
+          if (monaco5) {
+            const max = monaco5.getModel()?.getLineCount() ?? 0;
+            if (n < 1 || n > max) return;
+            if (opts?.center === false) {
+              monaco5.revealLine(n);
+            } else {
+              monaco5.revealLineInCenter(n);
+            }
+          } else {
+            const items = parseMarkdownOutline(markdown);
+            const preceding = items.filter((item) => item.line + fmOffset <= n).at(-1);
+            if (!preceding) return;
+            wysiwygRef.current?.scrollToHeading(preceding.id);
+          }
+        };
+        const scrollToHeading = (slug) => {
+          if (monaco5) {
+            const item = parseMarkdownOutline(markdown).find((i) => i.id === slug);
+            if (!item) return;
+            revealLine(item.line + fmOffset, { center: true });
+          } else {
+            wysiwygRef.current?.scrollToHeading(slug);
+          }
+        };
+        const getAccess = () => {
+          if (monaco5) return monacoContentAccess(monaco5);
+          if (wysiwygRef.current) return wysiwygRef.current;
+          return null;
+        };
+        return {
+          revealLine,
+          scrollToHeading,
+          getEditor: () => monaco5,
+          getElement: () => rootRef.current,
+          // EditorContentAccess — read/write delegate to the active engine at call
+          // time (the AI acts after mount, so a call-time snapshot is correct here).
+          getText: () => getAccess()?.getText() ?? "",
+          getSelection: () => getAccess()?.getSelection() ?? { text: "", empty: true },
+          replaceSelection: (text) => getAccess()?.replaceSelection(text),
+          insertAtCursor: (text) => getAccess()?.insertAtCursor(text),
+          focus: () => getAccess()?.focus(),
+          // onSelectionChange uses the STABLE listener set (not getAccess()) so a
+          // subscribe-in-mount-effect survives the editor's async mount + mode
+          // switches; the binding effect below forwards the active engine's events.
+          onSelectionChange: (listener) => {
+            selectionListeners.add(listener);
+            return () => selectionListeners.delete(listener);
+          }
+        };
+      },
+      // Re-create when the things the methods close over change.
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      [monaco5, markdown, fmOffset, activeMode, selectionListeners]
+    );
+    useEffect5(() => {
+      let unsub;
+      if (monaco5) {
+        unsub = monacoContentAccess(monaco5).onSelectionChange(
+          (sel) => selectionListeners.forEach((l) => l(sel))
+        );
+      } else if (activeMode === "wysiwyg" && wysiwygRef.current) {
+        unsub = wysiwygRef.current.onSelectionChange(
+          (sel) => selectionListeners.forEach((l) => l(sel))
+        );
+      }
+      return () => unsub?.();
+    }, [monaco5, activeMode, selectionListeners]);
+    const setMode = (next) => {
+      if (next !== "source" && next !== "split" && next !== "wysiwyg") return;
+      if (!mode) setInternalMode(next);
+      onModeChange?.(next);
+    };
+    const modeToggle = /* @__PURE__ */ jsx14(TooltipProvider2, { delayDuration: 300, children: /* @__PURE__ */ jsx14(
+      ToggleGroup,
+      {
+        type: "single",
+        value: activeMode,
+        onValueChange: setMode,
+        variant: "segmented",
+        size: "sm",
+        className: "rounded-md p-0.5",
+        children: MODES.map(({ value: m, label, icon: Icon }) => /* @__PURE__ */ jsxs12(Tooltip2, { children: [
+          /* @__PURE__ */ jsx14(TooltipTrigger2, { asChild: true, children: /* @__PURE__ */ jsx14(
+            ToggleGroupItem,
+            {
+              value: m,
+              "aria-label": label,
+              className: "h-6 min-w-7 rounded-[5px] px-2",
+              children: /* @__PURE__ */ jsx14(Icon, { className: "size-4" })
+            }
+          ) }),
+          /* @__PURE__ */ jsx14(TooltipContent2, { children: label })
+        ] }, m))
+      }
+    ) });
+    const trailing = /* @__PURE__ */ jsxs12(Fragment4, { children: [
+      modeSwitch ? modeToggle : null,
+      toolbarActions
+    ] });
+    const sourcePane = /* @__PURE__ */ jsx14(
+      CodeEditor,
+      {
+        language: "markdown",
+        value: markdown,
+        onChange: setMarkdown,
+        actions: sourceActions,
+        onMount: (editor2) => {
+          editor2.updateOptions({ wordWrap: "on" });
+          setMonaco(editor2);
+        }
+      }
+    );
+    return /* @__PURE__ */ jsxs12(
+      "div",
+      {
+        ref: rootRef,
+        "data-testid": "markdown-workspace",
+        className: cn13("flex h-full min-h-0 flex-col overflow-hidden", className),
+        ...props,
+        children: [
+          activeMode === "wysiwyg" ? /* @__PURE__ */ jsxs12("div", { className: "flex h-10 shrink-0 items-center justify-end gap-2 border-b border-border bg-surface px-2", children: [
+            focusWritingEnabled ? /* @__PURE__ */ jsx14(TooltipProvider2, { delayDuration: 300, children: /* @__PURE__ */ jsxs12(Tooltip2, { children: [
+              /* @__PURE__ */ jsx14(TooltipTrigger2, { asChild: true, children: /* @__PURE__ */ jsxs12(
+                Toggle,
+                {
+                  size: "sm",
+                  pressed: focusWritingOn,
+                  onPressedChange: setFocusWritingOn,
+                  "aria-label": "Focus writing",
+                  className: "h-6 gap-1.5 px-2 text-caption",
+                  children: [
+                    /* @__PURE__ */ jsx14(Focus, { className: "size-3.5", "aria-hidden": "true" }),
+                    " Focus"
+                  ]
+                }
+              ) }),
+              /* @__PURE__ */ jsx14(TooltipContent2, { children: "Typewriter scrolling \xB7 inactive paragraphs dim" })
+            ] }) }) : null,
+            trailing
+          ] }) : /* @__PURE__ */ jsx14(
+            MarkdownToolbar,
+            {
+              editor: monaco5,
+              actions: trailing,
+              insertCommands: toolbarInsertCommands
+            }
+          ),
+          /* @__PURE__ */ jsxs12("div", { className: "min-h-0 flex-1", children: [
+            activeMode === "source" ? sourcePane : null,
+            activeMode === "wysiwyg" ? /* @__PURE__ */ jsx14(
+              "div",
+              {
+                ref: wysiwygPaneRef,
+                "data-focus-writing": focusWritingEnabled && focusWritingOn ? "" : void 0,
+                className: "h-full overflow-auto p-4",
+                children: /* @__PURE__ */ jsx14(
+                  MarkdownEditor,
+                  {
+                    ref: wysiwygRef,
+                    defaultValue: markdown,
+                    onChange: onWysiwygChange,
+                    slashMenu,
+                    calc,
+                    completions,
+                    onEmbedAsset,
+                    className: "border-0"
+                  }
+                )
+              }
+            ) : null,
+            activeMode === "split" ? /* @__PURE__ */ jsxs12(ResizablePanelGroup, { direction: "horizontal", children: [
+              /* @__PURE__ */ jsx14(ResizablePanel, { defaultSize: 50, minSize: 25, children: sourcePane }),
+              /* @__PURE__ */ jsx14(ResizableHandle, { withHandle: true }),
+              /* @__PURE__ */ jsx14(ResizablePanel, { defaultSize: 50, minSize: 25, children: /* @__PURE__ */ jsx14(
+                "div",
+                {
+                  ref: previewPaneRef,
+                  onScroll: onPreviewScroll,
+                  className: "h-full overflow-auto p-5",
+                  children: /* @__PURE__ */ jsx14(MarkdownPreview, { children: markdown })
+                }
+              ) })
+            ] }) : null
+          ] }),
+          monaco5 && (activeMode === "source" || activeMode === "split") && slashEnabled ? /* @__PURE__ */ jsx14(
+            MonacoSlashMenu,
+            {
+              editor: monaco5,
+              commands: sourceCommands,
+              open: sourceSlashOpen,
+              onOpenChange: handleSourceSlashOpenChange,
+              triggerRange: typedTrigger
+            }
+          ) : null
+        ]
+      }
+    );
+  }
+);
+
+// src/markdown/parse.ts
+import remarkDirective2 from "remark-directive";
+import remarkFrontmatter from "remark-frontmatter";
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+var processor = unified().use(remarkParse).use(remarkGfm).use(remarkFrontmatter, ["yaml"]).use(remarkDirective2).freeze();
+function parseMarkdown(md) {
+  return processor.parse(md);
+}
+
+// src/mermaid-workspace/mermaid-workspace.tsx
+import { ResizableHandle as ResizableHandle2, ResizablePanel as ResizablePanel2, ResizablePanelGroup as ResizablePanelGroup2 } from "@elabs-ai/components-ui";
+import { cn as cn14 } from "@elabs-ai/components-ui/lib/cn";
+import { forwardRef as forwardRef10, useEffect as useEffect6, useState as useState6 } from "react";
+import { jsx as jsx15, jsxs as jsxs13 } from "react/jsx-runtime";
+var MermaidWorkspace = forwardRef10(
+  function MermaidWorkspace2({ value, defaultValue, onChange, debounceMs = 350, className, ...props }, ref) {
+    const isControlled = value !== void 0;
+    const [internal, setInternal] = useState6(value ?? defaultValue ?? "");
+    const source = isControlled ? value : internal;
+    const [debounced, setDebounced] = useState6(source);
+    useEffect6(() => {
+      const t = setTimeout(() => setDebounced(source), debounceMs);
+      return () => clearTimeout(t);
+    }, [source, debounceMs]);
+    const setSource = (next) => {
+      if (!isControlled) setInternal(next);
+      onChange?.(next);
+    };
+    return /* @__PURE__ */ jsx15(
+      "div",
+      {
+        ref,
+        "data-testid": "mermaid-workspace",
+        className: cn14("h-full min-h-0 overflow-hidden", className),
+        ...props,
+        children: /* @__PURE__ */ jsxs13(ResizablePanelGroup2, { direction: "horizontal", children: [
+          /* @__PURE__ */ jsx15(ResizablePanel2, { defaultSize: 45, minSize: 25, children: /* @__PURE__ */ jsx15(CodeEditor, { language: "plaintext", value: source, onChange: setSource }) }),
+          /* @__PURE__ */ jsx15(ResizableHandle2, { withHandle: true }),
+          /* @__PURE__ */ jsx15(ResizablePanel2, { defaultSize: 55, minSize: 25, children: /* @__PURE__ */ jsx15("div", { className: "h-full overflow-auto p-4", children: /* @__PURE__ */ jsx15(MermaidDiagram, { chart: debounced, label: "Diagram preview" }) }) })
+        ] })
+      }
+    );
+  }
+);
+
+// src/ai-objects/decision-card.tsx
+import {
+  Badge,
+  Card as Card2,
+  CardContent as CardContent2,
+  CardHeader as CardHeader2,
+  Separator as Separator5
+} from "@elabs-ai/components-ui";
+import { cn as cn15 } from "@elabs-ai/components-ui/lib/cn";
+import { cva } from "class-variance-authority";
+import { CheckCircle2, CircleDashed, Clock, RefreshCw } from "lucide-react";
+import {
+  forwardRef as forwardRef11
+} from "react";
+import { Fragment as Fragment5, jsx as jsx16, jsxs as jsxs14 } from "react/jsx-runtime";
+var DECISION_STATUSES = ["accepted", "rejected", "proposed", "superseded"];
+var STATUS_BADGE_VARIANT = {
+  accepted: "success",
+  rejected: "destructive",
+  proposed: "info",
+  superseded: "secondary"
+};
+var STATUS_LABELS = {
+  accepted: "Accepted",
+  rejected: "Rejected",
+  proposed: "Proposed",
+  superseded: "Superseded"
+};
+var STATUS_ICONS = {
+  accepted: CheckCircle2,
+  rejected: CircleDashed,
+  proposed: Clock,
+  superseded: RefreshCw
+};
+function isDecisionStatus(s) {
+  return DECISION_STATUSES.includes(s);
+}
+var decisionCardVariants = cva("border-s-4", {
+  variants: {
+    status: {
+      accepted: "border-s-success",
+      rejected: "border-s-destructive",
+      proposed: "border-s-info",
+      superseded: "border-s-border"
+    }
+  },
+  defaultVariants: { status: "proposed" }
+});
+var DecisionCard = forwardRef11(function DecisionCard2({ status: rawStatus, date, alternatives, children, className, ...props }, ref) {
+  const status = isDecisionStatus(rawStatus ?? "") ? rawStatus : "proposed";
+  const badgeVariant = STATUS_BADGE_VARIANT[status];
+  const label = STATUS_LABELS[status];
+  const Icon = STATUS_ICONS[status];
+  const altItems = alternatives ? alternatives.split(",").map((s) => s.trim()).filter(Boolean) : [];
+  return /* @__PURE__ */ jsx16(
+    "section",
+    {
+      ref,
+      "aria-label": `Decision: ${label}`,
+      className: cn15("not-prose", className),
+      ...props,
+      children: /* @__PURE__ */ jsxs14(Card2, { className: cn15(decisionCardVariants({ status })), children: [
+        /* @__PURE__ */ jsx16(CardHeader2, { className: "pb-3", children: /* @__PURE__ */ jsxs14("div", { className: "flex flex-wrap items-center gap-2", children: [
+          /* @__PURE__ */ jsxs14(Badge, { variant: badgeVariant, className: "gap-1.5", children: [
+            /* @__PURE__ */ jsx16(Icon, { className: "size-3", "aria-hidden": "true" }),
+            label
+          ] }),
+          date ? /* @__PURE__ */ jsx16("time", { dateTime: date, className: "text-meta text-muted-foreground tabular-nums", children: date }) : null
+        ] }) }),
+        children ? /* @__PURE__ */ jsx16(CardContent2, { className: "text-body text-foreground", children }) : null,
+        altItems.length > 0 ? /* @__PURE__ */ jsxs14(Fragment5, { children: [
+          /* @__PURE__ */ jsx16(Separator5, {}),
+          /* @__PURE__ */ jsxs14("div", { className: "px-6 py-4", children: [
+            /* @__PURE__ */ jsx16("p", { className: "mb-2 text-meta font-medium text-muted-foreground", children: "Alternatives considered" }),
+            /* @__PURE__ */ jsx16("ul", { className: "flex flex-wrap gap-1.5", "aria-label": "Alternatives considered", children: altItems.map((alt) => /* @__PURE__ */ jsx16("li", { children: /* @__PURE__ */ jsx16(Badge, { variant: "outline", className: "text-meta", children: alt }) }, alt)) })
+          ] })
+        ] }) : null
+      ] })
+    }
+  );
+});
+
+// src/ai-objects/entity.tsx
+import { Card as Card3, CardContent as CardContent3, CardHeader as CardHeader3, CardTitle as CardTitle2 } from "@elabs-ai/components-ui";
+import { cn as cn16 } from "@elabs-ai/components-ui/lib/cn";
+import { cva as cva2 } from "class-variance-authority";
+import { Box, Building2, Lightbulb, MapPin, Tag, User } from "lucide-react";
+import {
+  forwardRef as forwardRef12
+} from "react";
+import { jsx as jsx17, jsxs as jsxs15 } from "react/jsx-runtime";
+var ENTITY_KINDS = ["org", "person", "place", "product", "concept"];
+var KIND_META = {
+  org: { Icon: Building2, label: "Organisation" },
+  person: { Icon: User, label: "Person" },
+  place: { Icon: MapPin, label: "Place" },
+  product: { Icon: Box, label: "Product" },
+  concept: { Icon: Lightbulb, label: "Concept" }
+};
+var DEFAULT_KIND_META = { Icon: Tag, label: "Entity" };
+function kindMeta(kind) {
+  return KIND_META[kind ?? ""] ?? DEFAULT_KIND_META;
+}
+var entityChipVariants = cva2(
+  // inline-flex + align-middle keeps the chip in the text baseline;
+  // no `block` wrapper so it is valid inside <p>.
+  "inline-flex items-center gap-1 rounded-sm border px-1.5 py-0.5 text-meta font-medium align-middle focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
+  {
+    variants: {
+      kind: {
+        org: "border-border bg-secondary/60 text-secondary-foreground",
+        // #399 — same reasoning as `concept` below: a 10% WASH is not a plate
+        // and not a mark, so the LABEL takes the on-surface `-text` rung. This
+        // is the row that had no `-text` rung to reach for until #399 minted it.
+        person: "border-primary/30 bg-primary/10 text-primary-text",
+        place: "border-info/30 bg-info/10 text-info-text",
+        product: "border-success/30 bg-success/10 text-success-text",
+        // `-text`, not `-foreground`: the chip is a 10% WASH on the page surface,
+        // not a solid `--warning` plate, so it needs the on-surface rung its
+        // place/product siblings use (#381 flipped `--warning-foreground` to
+        // light ink for the now-deep fill).
+        concept: "border-warning/30 bg-warning/10 text-warning-text",
+        default: "border-border text-foreground"
+      }
+    },
+    defaultVariants: { kind: "default" }
+  }
+);
+function chipKind(kind) {
+  if (!kind) return "default";
+  const known = [
+    "org",
+    "person",
+    "place",
+    "product",
+    "concept",
+    "default"
+  ];
+  return known.includes(kind) ? kind : "default";
+}
+var EntityChip = forwardRef12(function EntityChip2({ kind: rawKind, children, className, ...props }, ref) {
+  const { Icon, label } = kindMeta(rawKind);
+  const resolvedKind = chipKind(rawKind);
+  return /* @__PURE__ */ jsxs15(
+    "span",
+    {
+      ref,
+      role: "mark",
+      "aria-label": children ? `${String(children)} (${label})` : label,
+      className: cn16(entityChipVariants({ kind: resolvedKind }), className),
+      ...props,
+      children: [
+        /* @__PURE__ */ jsx17(Icon, { className: "size-3 shrink-0", "aria-hidden": "true" }),
+        /* @__PURE__ */ jsx17("span", { children })
+      ]
+    }
+  );
+});
+var EntityCard = forwardRef12(function EntityCard2({ kind: rawKind, name, children, className, ...props }, ref) {
+  const { Icon, label } = kindMeta(rawKind);
+  return /* @__PURE__ */ jsx17(
+    "section",
+    {
+      ref,
+      "aria-label": name ? `${label}: ${name}` : label,
+      className: cn16("not-prose", className),
+      ...props,
+      children: /* @__PURE__ */ jsxs15(Card3, { children: [
+        /* @__PURE__ */ jsx17(CardHeader3, { className: "pb-3", children: /* @__PURE__ */ jsxs15("div", { className: "flex items-center gap-2", children: [
+          /* @__PURE__ */ jsx17(
+            "span",
+            {
+              className: "flex size-7 shrink-0 items-center justify-center rounded-md bg-muted",
+              "aria-hidden": "true",
+              children: /* @__PURE__ */ jsx17(Icon, { className: "size-4 text-muted-foreground" })
+            }
+          ),
+          /* @__PURE__ */ jsxs15("div", { className: "min-w-0", children: [
+            name ? /* @__PURE__ */ jsx17(CardTitle2, { className: "truncate", children: name }) : null,
+            /* @__PURE__ */ jsx17("p", { className: "text-meta text-muted-foreground", children: label })
+          ] })
+        ] }) }),
+        children ? /* @__PURE__ */ jsx17(CardContent3, { className: "text-body text-foreground", children }) : null
+      ] })
+    }
+  );
+});
+
+// src/ai-objects/knowledge-card.tsx
+import { Card as Card4, CardContent as CardContent4, CardFooter } from "@elabs-ai/components-ui";
+import { cn as cn17 } from "@elabs-ai/components-ui/lib/cn";
+import { BookOpen, FileText } from "lucide-react";
+import { forwardRef as forwardRef13 } from "react";
+import { jsx as jsx18, jsxs as jsxs16 } from "react/jsx-runtime";
+function SourceRow({ path, resolve }) {
+  const resolved = resolve ? resolve(path) : null;
+  const display = resolved?.title ?? path;
+  if (resolved) {
+    return /* @__PURE__ */ jsxs16(
+      "a",
+      {
+        href: resolved.href,
+        rel: "noopener noreferrer",
+        target: "_blank",
+        className: "flex min-w-0 items-center gap-1.5 text-meta text-primary-text underline-offset-2 hover:underline focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring",
+        "aria-label": `Source: ${display}`,
+        children: [
+          /* @__PURE__ */ jsx18(FileText, { className: "size-3 shrink-0", "aria-hidden": "true" }),
+          /* @__PURE__ */ jsx18("span", { className: "truncate", children: display })
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs16(
+    "span",
+    {
+      className: "flex min-w-0 items-center gap-1.5 text-meta text-muted-foreground",
+      "aria-label": `Source (unresolved): ${display}`,
+      children: [
+        /* @__PURE__ */ jsx18(FileText, { className: "size-3 shrink-0", "aria-hidden": "true" }),
+        /* @__PURE__ */ jsx18("span", { className: "truncate", children: display })
+      ]
+    }
+  );
+}
+var KnowledgeCard = forwardRef13(function KnowledgeCard2({ sources, resolve, children, className, ...props }, ref) {
+  const sourcePaths = sources ? sources.split(",").map((s) => s.trim()).filter(Boolean) : [];
+  return /* @__PURE__ */ jsx18(
+    "section",
+    {
+      ref,
+      "aria-label": "Knowledge fact",
+      className: cn17("not-prose", className),
+      ...props,
+      children: /* @__PURE__ */ jsxs16(Card4, { className: "border-s-4 border-s-info", children: [
+        /* @__PURE__ */ jsxs16(CardContent4, { className: "pt-4", children: [
+          /* @__PURE__ */ jsxs16("div", { className: "mb-2 flex items-center gap-1.5", children: [
+            /* @__PURE__ */ jsx18(BookOpen, { className: "size-3.5 shrink-0 text-info-text", "aria-hidden": "true" }),
+            /* @__PURE__ */ jsx18("span", { className: "text-meta font-medium text-info-text", children: "Knowledge" })
+          ] }),
+          /* @__PURE__ */ jsx18("div", { className: "text-body text-foreground", children })
+        ] }),
+        sourcePaths.length > 0 ? /* @__PURE__ */ jsxs16(CardFooter, { className: "flex-col items-start gap-1 border-t border-border pt-3", children: [
+          /* @__PURE__ */ jsx18("p", { className: "text-meta font-medium text-muted-foreground", children: "Sources" }),
+          /* @__PURE__ */ jsx18("ul", { className: "flex w-full flex-col gap-1", "aria-label": "Sources", children: sourcePaths.map((path) => /* @__PURE__ */ jsx18("li", { className: "min-w-0", children: /* @__PURE__ */ jsx18(SourceRow, { path, resolve }) }, path)) })
+        ] }) : null
+      ] })
+    }
+  );
+});
+
+// src/ai-objects/directives.ts
+import { createElement } from "react";
+function decisionDirective() {
+  return {
+    name: "decision",
+    kinds: ["container"],
+    render({ attributes, children }) {
+      return createElement(DecisionCard, {
+        status: attributes.status,
+        date: attributes.date,
+        alternatives: attributes.alternatives,
+        children
+      });
+    }
+  };
+}
+function entityDirective() {
+  return {
+    name: "entity",
+    kinds: ["container", "inline"],
+    render({ kind, attributes, children, textValue }) {
+      if (kind === "inline") {
+        const label = textValue ?? (typeof children === "string" ? children : void 0);
+        return createElement(EntityChip, { kind: attributes.kind, children: label ?? children });
+      }
+      return createElement(EntityCard, {
+        kind: attributes.kind,
+        name: attributes.name,
+        children
+      });
+    }
+  };
+}
+function knowledgeDirective(options) {
+  return {
+    name: "knowledge",
+    kinds: ["container"],
+    render({ attributes, children }) {
+      return createElement(KnowledgeCard, {
+        sources: attributes.sources,
+        resolve: options?.resolve,
+        children
+      });
+    }
+  };
+}
+function aiObjectDirectives(options = {}) {
+  return [
+    decisionDirective(),
+    entityDirective(),
+    knowledgeDirective({ resolve: options.resolveKnowledge })
+  ];
+}
+
+// src/markdown-iteration/template-dialog.tsx
+import {
+  Button as Button4,
+  Dialog as Dialog2,
+  DialogContent as DialogContent2,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle as DialogTitle2
+} from "@elabs-ai/components-ui";
+import { useEffect as useEffect7, useState as useState7 } from "react";
+import { jsx as jsx19, jsxs as jsxs17 } from "react/jsx-runtime";
+function IterationTemplateDialog({
+  open,
+  onOpenChange,
+  template,
+  onSave,
+  kind = "iterate",
+  mode = "split"
+}) {
+  const [draft, setDraft] = useState7(template);
+  useEffect7(() => {
+    if (open) setDraft(template);
+  }, [open, template]);
+  const unit = kind === "pivot" ? "cell" : "row";
+  const save = () => {
+    onSave(draft);
+    onOpenChange(false);
+  };
+  return /* @__PURE__ */ jsx19(Dialog2, { open, onOpenChange, children: /* @__PURE__ */ jsxs17(DialogContent2, { className: "flex max-h-[85vh] w-[min(48rem,92vw)] max-w-none flex-col", children: [
+    /* @__PURE__ */ jsxs17(DialogHeader, { children: [
+      /* @__PURE__ */ jsxs17(DialogTitle2, { children: [
+        "Edit ",
+        kind === "pivot" ? "pivot" : "iteration",
+        " template"
+      ] }),
+      /* @__PURE__ */ jsxs17(DialogDescription, { children: [
+        "The per-",
+        unit,
+        " template. Use ",
+        /* @__PURE__ */ jsx19("code", { children: "{{token}}" }),
+        " placeholders (e.g.",
+        " ",
+        /* @__PURE__ */ jsx19("code", { children: "{{item.name}}" }),
+        ") \u2014 each is filled per ",
+        unit,
+        " when the block renders."
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx19("div", { className: "min-h-0 flex-1", children: /* @__PURE__ */ jsx19(
+      MarkdownWorkspace,
+      {
+        value: draft,
+        onChange: setDraft,
+        defaultMode: mode,
+        className: "h-full",
+        "aria-label": "Iteration template editor"
+      }
+    ) }),
+    /* @__PURE__ */ jsxs17(DialogFooter, { children: [
+      /* @__PURE__ */ jsx19(Button4, { variant: "ghost", onClick: () => onOpenChange(false), children: "Cancel" }),
+      /* @__PURE__ */ jsx19(Button4, { onClick: save, children: "Save template" })
+    ] })
+  ] }) });
+}
+function IterationTemplateProvider({ children }) {
+  const [request, setRequest] = useState7(null);
+  return /* @__PURE__ */ jsxs17(IterationEditContext.Provider, { value: setRequest, children: [
+    children,
+    /* @__PURE__ */ jsx19(
+      IterationTemplateDialog,
+      {
+        open: request != null,
+        onOpenChange: (next) => {
+          if (!next) setRequest(null);
+        },
+        template: request?.template ?? "",
+        kind: request?.kind ?? "iterate",
+        onSave: (template) => request?.onSave(template)
+      }
+    )
+  ] });
+}
+
+// src/markdown-iteration/iteration-builder-dialog.tsx
+import {
+  Button as Button5,
+  Dialog as Dialog3,
+  DialogBody,
+  DialogContent as DialogContent3,
+  DialogDescription as DialogDescription2,
+  DialogFooter as DialogFooter2,
+  DialogHeader as DialogHeader2,
+  DialogTitle as DialogTitle3,
+  Input as Input2,
+  Label,
+  TagInput,
+  ToggleGroup as ToggleGroup2,
+  ToggleGroupItem as ToggleGroupItem2
+} from "@elabs-ai/components-ui";
+import { useEffect as useEffect8, useId as useId4, useMemo as useMemo7, useState as useState8 } from "react";
+import { jsx as jsx20, jsxs as jsxs18 } from "react/jsx-runtime";
+function IterationBuilderDialog({
+  open,
+  onOpenChange,
+  kind: kindProp = "iterate",
+  value,
+  initialValues,
+  onSave,
+  evaluate,
+  interpolate
+}) {
+  const kind = value?.kind ?? kindProp;
+  const isPivot = kind === "pivot";
+  const ids = useId4();
+  const [asName, setAsName] = useState8("item");
+  const [layout, setLayout] = useState8(ITERATION_LAYOUTS[kind][0] ?? "stacked");
+  const [values, setValues] = useState8([]);
+  const [cols, setCols] = useState8([]);
+  const [template, setTemplate] = useState8("");
+  useEffect8(() => {
+    if (!open) return;
+    const seed = value ?? {
+      ...emptyBuilderValue(kind),
+      values: initialValues ?? []
+    };
+    setAsName(seed.as);
+    setLayout(seed.layout);
+    setValues(seed.values);
+    setCols(seed.cols ?? []);
+    setTemplate(seed.template);
+  }, [open]);
+  const draft = useMemo7(
+    () => ({
+      kind,
+      as: asName.trim() || "item",
+      layout,
+      values,
+      cols: isPivot ? cols : void 0,
+      template
+    }),
+    [kind, asName, layout, values, cols, template, isPivot]
+  );
+  const previewMarkdown = useMemo7(() => serializeIterationDirective(draft), [draft]);
+  const save = () => {
+    onSave(serializeIterationDirective(draft));
+    onOpenChange(false);
+  };
+  const noun = isPivot ? "pivot" : "iteration";
+  return /* @__PURE__ */ jsx20(Dialog3, { open, onOpenChange, children: /* @__PURE__ */ jsxs18(DialogContent3, { className: "flex max-h-[88vh] w-[min(56rem,94vw)] max-w-none flex-col", children: [
+    /* @__PURE__ */ jsxs18(DialogHeader2, { children: [
+      /* @__PURE__ */ jsxs18(DialogTitle3, { children: [
+        value ? "Edit" : "Insert",
+        " ",
+        noun
+      ] }),
+      /* @__PURE__ */ jsx20(DialogDescription2, { children: isPivot ? "Pick the row and column values, then write the per-cell template. The matrix below fills in live." : "Add the list values, then write the per-row template. The result below fills in live." })
+    ] }),
+    /* @__PURE__ */ jsxs18(DialogBody, { className: "grid gap-4 md:grid-cols-2", children: [
+      /* @__PURE__ */ jsxs18("div", { className: "flex min-w-0 flex-col gap-4", children: [
+        !isPivot ? /* @__PURE__ */ jsxs18("div", { className: "flex flex-col gap-1.5", children: [
+          /* @__PURE__ */ jsx20(Label, { htmlFor: `${ids}-as`, children: "Bind name" }),
+          /* @__PURE__ */ jsx20(
+            Input2,
+            {
+              id: `${ids}-as`,
+              value: asName,
+              spellCheck: false,
+              autoComplete: "off",
+              placeholder: "item",
+              onChange: (e) => setAsName(e.target.value)
+            }
+          ),
+          /* @__PURE__ */ jsxs18("p", { className: "text-meta text-muted-foreground", children: [
+            "Use ",
+            /* @__PURE__ */ jsx20("code", { children: `{{${asName.trim() || "item"}.name}}` }),
+            " in the template."
+          ] })
+        ] }) : null,
+        /* @__PURE__ */ jsxs18("div", { className: "flex flex-col gap-1.5", children: [
+          /* @__PURE__ */ jsx20(Label, { htmlFor: `${ids}-values`, children: isPivot ? "Row values" : "Values" }),
+          /* @__PURE__ */ jsx20(
+            TagInput,
+            {
+              id: `${ids}-values`,
+              value: values,
+              onValueChange: setValues,
+              delimiter: [",", "\n"],
+              placeholder: "Type a value, press Enter\u2026"
+            }
+          )
+        ] }),
+        isPivot ? /* @__PURE__ */ jsxs18("div", { className: "flex flex-col gap-1.5", children: [
+          /* @__PURE__ */ jsx20(Label, { htmlFor: `${ids}-cols`, children: "Column values" }),
+          /* @__PURE__ */ jsx20(
+            TagInput,
+            {
+              id: `${ids}-cols`,
+              value: cols,
+              onValueChange: setCols,
+              delimiter: [",", "\n"],
+              placeholder: "Type a value, press Enter\u2026"
+            }
+          )
+        ] }) : null,
+        /* @__PURE__ */ jsxs18("div", { className: "flex flex-col gap-1.5", children: [
+          /* @__PURE__ */ jsx20(Label, { id: `${ids}-layout`, children: "Layout" }),
+          /* @__PURE__ */ jsx20(
+            ToggleGroup2,
+            {
+              type: "single",
+              variant: "segmented",
+              value: layout,
+              onValueChange: (next) => {
+                if (next) setLayout(next);
+              },
+              "aria-labelledby": `${ids}-layout`,
+              className: "w-fit",
+              children: ITERATION_LAYOUTS[kind].map((l) => /* @__PURE__ */ jsx20(ToggleGroupItem2, { value: l, className: "capitalize", children: l }, l))
+            }
+          )
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs18("div", { className: "flex min-h-0 min-w-0 flex-col gap-4", children: [
+        /* @__PURE__ */ jsxs18("div", { className: "flex min-h-0 flex-col gap-1.5", children: [
+          /* @__PURE__ */ jsxs18(Label, { children: [
+            "Per-",
+            isPivot ? "cell" : "row",
+            " template"
+          ] }),
+          /* @__PURE__ */ jsx20("div", { className: "h-44 min-h-0 overflow-hidden rounded-md border border-border", children: /* @__PURE__ */ jsx20(
+            MarkdownWorkspace,
+            {
+              value: template,
+              onChange: setTemplate,
+              defaultMode: "source",
+              className: "h-full",
+              "aria-label": "Per-cell template"
+            }
+          ) })
+        ] }),
+        /* @__PURE__ */ jsxs18("div", { className: "flex min-h-0 flex-col gap-1.5", children: [
+          /* @__PURE__ */ jsx20(Label, { children: "Live preview" }),
+          /* @__PURE__ */ jsx20(
+            "div",
+            {
+              role: "region",
+              "aria-label": "Live preview",
+              className: "min-h-0 flex-1 overflow-auto rounded-md border border-border bg-card p-3",
+              children: /* @__PURE__ */ jsx20(
+                MarkdownPreview,
+                {
+                  evaluateIteration: evaluateEmbedded,
+                  evaluate,
+                  interpolate,
+                  children: previewMarkdown
+                }
+              )
+            }
+          )
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs18(DialogFooter2, { children: [
+      /* @__PURE__ */ jsx20(Button5, { variant: "ghost", onClick: () => onOpenChange(false), children: "Cancel" }),
+      /* @__PURE__ */ jsx20(Button5, { onClick: save, children: value ? "Save" : "Insert" })
+    ] })
+  ] }) });
+}
+function IterationBuilderProvider({
+  children,
+  evaluate,
+  interpolate
+}) {
+  const [request, setRequest] = useState8(null);
+  const seed = request ? builderValueFromParts(request.kind, request.attributes ?? {}, request.template) : void 0;
+  return /* @__PURE__ */ jsxs18(IterationEditContext.Provider, { value: setRequest, children: [
+    children,
+    /* @__PURE__ */ jsx20(
+      IterationBuilderDialog,
+      {
+        open: request != null,
+        onOpenChange: (next) => {
+          if (!next) setRequest(null);
+        },
+        kind: request?.kind ?? "iterate",
+        value: seed,
+        evaluate,
+        interpolate,
+        onSave: (directiveMarkdown) => {
+          const parsed = parseIterationDirective(directiveMarkdown);
+          if (!parsed) return;
+          const { attributes, template } = directivePartsFromValue(parsed);
+          if (request?.onSaveData) request.onSaveData({ attributes, template });
+          else request?.onSave(template);
+        }
+      }
+    )
+  ] });
+}
+export {
+  BRAND_DIRECTIVES,
+  BRAND_SLASH_COMMANDS,
+  Bibliography,
+  ProseBlockquote as Blockquote,
+  CALC_FENCE_SEED,
+  CalcBlock,
+  CalcInline,
+  DECISION_STATUSES,
+  DEFAULT_TEMPLATE,
+  DecisionCard,
+  DocumentOutline,
+  ENTITY_KINDS,
+  EntityCard,
+  EntityChip,
+  FootnoteList,
+  ProseHeading as Heading,
+  ProseInlineCode as InlineCode,
+  IterationBlock,
+  IterationBuilderDialog,
+  IterationBuilderProvider,
+  IterationEditContext,
+  IterationTemplateDialog,
+  IterationTemplateProvider,
+  KnowledgeCard,
+  ProseLink as Link,
+  ProseList as List,
+  ProseListItem as ListItem,
+  MARKDOWN_HEADING_REM,
+  MARKDOWN_HEADING_TRACKING,
+  MARKDOWN_HEADING_WEIGHT,
+  MARKDOWN_MEASURE,
+  MarkdownEditor,
+  MarkdownPreview,
+  MarkdownToolbar,
+  MarkdownWorkspace,
+  MathBlock,
+  MathInline,
+  MermaidDiagram,
+  MermaidWorkspace,
+  MetricBlock,
+  MonacoSlashMenu,
+  SlashMenu,
+  TableOfContents,
+  ProseText as Text,
+  Timeline,
+  aiObjectDirectives,
+  annotationForRange,
+  attachCalcMonaco,
+  attachCompletionsMonaco,
+  brandSlashViewPlugins,
+  buildMarkdownPlugins,
+  builderValueFromParts,
+  calcProsePlugins,
+  calcTokenClassName,
+  collectCitations,
+  collectCompletions,
+  computeMarkdownAnnotations,
+  decisionCardVariants,
+  decisionDirective,
+  defaultInterpolate,
+  directivePartsFromValue,
+  emptyBuilderValue,
+  entityChipVariants,
+  entityDirective,
+  evaluateEmbedded,
+  filterSlashCommands,
+  findCalcFences,
+  groupSlashCommands,
+  insertBasicBlock,
+  insertBrandDirective,
+  insertCalcFence,
+  insertDirective,
+  insertHorizontalRule,
+  insertLink,
+  knowledgeDirective,
+  markdownScaleVars,
+  mergeNormalizedEdit,
+  monacoContentAccess,
+  parseAttributes,
+  parseFrontmatter,
+  parseIterationDirective,
+  parseMarkdown,
+  parseMarkdownOutline,
+  proseMirrorContentAccess,
+  remarkBrandDirectives,
+  removedMarkerAt,
+  resolveCalcInsert,
+  resolveReplaceRange,
+  selectionWatchPlugin,
+  serializeFrontmatter,
+  serializeIterationDirective,
+  shiftAnnotations,
+  specFromDirective,
+  splitList,
+  staticMarkdownFromValue,
+  summarizeAnnotations,
+  toggleLinePrefix,
+  transposeIterationValue,
+  triggerQueryStart,
+  useMarkdownOutline,
+  wrapSelection
+};
+//# sourceMappingURL=index.js.map