@orchestra-mcp/editor 0.2.0

package/dist/index.cjs

@@ -0,0 +1,2338 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/CodeEditor/lsp-bridge.ts
+var lsp_bridge_exports = {};
+__export(lsp_bridge_exports, {
+  connectLanguageServer: () => connectLanguageServer
+});
+async function connectLanguageServer(monaco, editor, languageId, wsUrl) {
+  const ws = new WebSocket(wsUrl);
+  const pending = /* @__PURE__ */ new Map();
+  const disposables = [];
+  function send(msg) {
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify(msg));
+    }
+  }
+  function request(method, params) {
+    const id = _requestId++;
+    send({ jsonrpc: "2.0", id, method, params });
+    return new Promise((resolve, reject) => {
+      pending.set(id, { resolve, reject });
+    });
+  }
+  function notify(method, params) {
+    send({ jsonrpc: "2.0", method, params });
+  }
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      ws.close();
+      reject(new Error(`LSP server not reachable at ${wsUrl}`));
+    }, 5e3);
+    ws.onerror = () => {
+      clearTimeout(timeout);
+      reject(new Error(`LSP WebSocket error for ${languageId}`));
+    };
+    ws.onmessage = (event) => {
+      try {
+        const msg = JSON.parse(event.data);
+        if (msg.id !== void 0 && pending.has(msg.id)) {
+          const p = pending.get(msg.id);
+          pending.delete(msg.id);
+          if (msg.error) p.reject(msg.error);
+          else p.resolve(msg.result);
+        } else if (msg.method === "textDocument/publishDiagnostics") {
+          const params = msg.params;
+          if (params) handleDiagnostics(monaco, params.uri, params.diagnostics);
+        }
+      } catch {
+      }
+    };
+    ws.onopen = async () => {
+      clearTimeout(timeout);
+      await request("initialize", {
+        processId: null,
+        clientInfo: { name: "orchestra-mcp", version: "1.0" },
+        capabilities: {
+          textDocument: {
+            hover: { contentFormat: ["markdown", "plaintext"] },
+            completion: { completionItem: { snippetSupport: true } },
+            publishDiagnostics: {}
+          }
+        },
+        rootUri: null
+      });
+      notify("initialized", {});
+      const model = editor.getModel();
+      if (model) {
+        notify("textDocument/didOpen", {
+          textDocument: {
+            uri: model.uri.toString(),
+            languageId,
+            version: model.getVersionId(),
+            text: model.getValue()
+          }
+        });
+        const changeDisposable = model.onDidChangeContent((e) => {
+          notify("textDocument/didChange", {
+            textDocument: { uri: model.uri.toString(), version: model.getVersionId() },
+            contentChanges: e.changes.map((c) => ({
+              range: c.range,
+              rangeLength: c.rangeLength,
+              text: c.text
+            }))
+          });
+        });
+        disposables.push(changeDisposable);
+        const hoverDisposable = monaco.languages.registerHoverProvider(languageId, {
+          provideHover: async (_m, position) => {
+            try {
+              const result = await request("textDocument/hover", {
+                textDocument: { uri: model.uri.toString() },
+                position: { line: position.lineNumber - 1, character: position.column - 1 }
+              });
+              if (!result?.contents) return null;
+              const contents = Array.isArray(result.contents) ? result.contents.map((c) => typeof c === "string" ? { value: c } : c) : [typeof result.contents === "string" ? { value: result.contents } : result.contents];
+              return { contents };
+            } catch {
+              return null;
+            }
+          }
+        });
+        disposables.push(hoverDisposable);
+        const completionDisposable = monaco.languages.registerCompletionItemProvider(languageId, {
+          provideCompletionItems: async (_m, position) => {
+            try {
+              const result = await request("textDocument/completion", {
+                textDocument: { uri: model.uri.toString() },
+                position: { line: position.lineNumber - 1, character: position.column - 1 }
+              });
+              const items = Array.isArray(result) ? result : result?.items ?? [];
+              return { suggestions: items };
+            } catch {
+              return { suggestions: [] };
+            }
+          }
+        });
+        disposables.push(completionDisposable);
+      }
+      resolve({
+        dispose: () => {
+          const model2 = editor.getModel();
+          if (model2) {
+            notify("textDocument/didClose", {
+              textDocument: { uri: model2.uri.toString() }
+            });
+          }
+          disposables.forEach((d) => d.dispose());
+          ws.close();
+        }
+      });
+    };
+  });
+}
+function handleDiagnostics(monaco, uri, diagnostics) {
+  const model = monaco.editor.getModels().find((m) => m.uri.toString() === uri);
+  if (!model) return;
+  const markers = diagnostics.map((d) => ({
+    startLineNumber: d.range.start.line + 1,
+    startColumn: d.range.start.character + 1,
+    endLineNumber: d.range.end.line + 1,
+    endColumn: d.range.end.character + 1,
+    severity: d.severity === 1 ? monaco.MarkerSeverity.Error : d.severity === 2 ? monaco.MarkerSeverity.Warning : monaco.MarkerSeverity.Info,
+    message: d.message,
+    source: d.source
+  }));
+  monaco.editor.setModelMarkers(model, "lsp", markers);
+}
+var _requestId;
+var init_lsp_bridge = __esm({
+  "src/CodeEditor/lsp-bridge.ts"() {
+    "use strict";
+    _requestId = 1;
+  }
+});
+
+// src/utils/exportToImage.ts
+var exportToImage_exports = {};
+__export(exportToImage_exports, {
+  exportToImage: () => exportToImage
+});
+async function exportToImage(element, filename = "export", padding = 40) {
+  const { toPng } = await import("html-to-image");
+  const computed = getComputedStyle(element);
+  const accent = computed.getPropertyValue("--color-accent").trim() || "#7c3aed";
+  const bgColor = computed.getPropertyValue("--color-bg").trim() || "#1e1e2e";
+  const bgContrast = computed.getPropertyValue("--color-bg-contrast").trim() || bgColor;
+  const fgColor = computed.getPropertyValue("--color-fg").trim() || "#e4e4e7";
+  const fgMuted = computed.getPropertyValue("--color-fg-muted").trim() || "#a1a1aa";
+  const borderColor = computed.getPropertyValue("--color-border").trim() || "#27272a";
+  const gradient = `linear-gradient(135deg, ${accent}22 0%, ${bgContrast} 40%, ${bgColor} 100%)`;
+  const wrapper = document.createElement("div");
+  wrapper.style.display = "inline-block";
+  wrapper.style.padding = `${padding}px`;
+  wrapper.style.borderRadius = "16px";
+  wrapper.style.background = gradient;
+  wrapper.style.setProperty("--color-accent", accent);
+  wrapper.style.setProperty("--color-bg", bgColor);
+  wrapper.style.setProperty("--color-bg-contrast", bgContrast);
+  wrapper.style.setProperty("--color-fg", fgColor);
+  wrapper.style.setProperty("--color-fg-muted", fgMuted);
+  wrapper.style.setProperty("--color-border", borderColor);
+  const parent = element.parentNode;
+  const nextSibling = element.nextSibling;
+  wrapper.appendChild(element);
+  document.body.appendChild(wrapper);
+  element.classList.add("code-block--exporting");
+  element.classList.add("data-table--exporting");
+  const origBorderRadius = element.style.borderRadius;
+  element.style.borderRadius = "12px";
+  try {
+    const dataUrl = await toPng(wrapper, {
+      pixelRatio: 2,
+      backgroundColor: bgColor
+    });
+    const res = await fetch(dataUrl);
+    const blob = await res.blob();
+    const fullFilename = (0, import_widgets.uuidFilename)(filename, "png");
+    await (0, import_widgets.saveBlob)(blob, fullFilename, "image/png");
+  } finally {
+    element.classList.remove("code-block--exporting");
+    element.classList.remove("data-table--exporting");
+    element.style.borderRadius = origBorderRadius;
+    if (parent) {
+      if (nextSibling) {
+        parent.insertBefore(element, nextSibling);
+      } else {
+        parent.appendChild(element);
+      }
+    }
+    wrapper.remove();
+  }
+}
+var import_widgets;
+var init_exportToImage = __esm({
+  "src/utils/exportToImage.ts"() {
+    "use strict";
+    import_widgets = require("@orchestra-mcp/widgets");
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CodeBlock: () => CodeBlock,
+  CodeDiffEditor: () => CodeDiffEditor,
+  CodeEditor: () => CodeEditor,
+  GitDiffView: () => GitDiffView,
+  LegacyCodeEditor: () => LegacyCodeEditor,
+  MarkdownEditor: () => MarkdownEditor,
+  MarkdownRenderer: () => MarkdownRenderer,
+  computeDiff: () => computeDiff,
+  exportToImage: () => exportToImage,
+  getMonacoThemeId: () => getMonacoThemeId,
+  languageFromFilename: () => languageFromFilename,
+  orchestraToMonacoTheme: () => orchestraToMonacoTheme,
+  resolveLanguage: () => resolveLanguage
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/CodeEditor/CodeEditor.tsx
+var import_react7 = require("react");
+
+// src/CodeEditor/MonacoLoader.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var MonacoEditor = (0, import_react.lazy)(
+  () => import("@monaco-editor/react").then((mod) => ({ default: mod.Editor }))
+);
+var MonacoDiffEditor = (0, import_react.lazy)(
+  () => import("@monaco-editor/react").then((mod) => ({ default: mod.DiffEditor }))
+);
+function DefaultLoading() {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "code-editor__loading", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "code-editor__loading-shimmer" }) });
+}
+function MonacoSuspense({ children, loading }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react.Suspense, { fallback: loading ?? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(DefaultLoading, {}), children });
+}
+
+// src/CodeEditor/LegacyCodeEditor.tsx
+var import_react2 = require("react");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var LegacyCodeEditor = ({
+  value,
+  language,
+  onChange,
+  readOnly = false,
+  lineNumbers = true,
+  height = 400,
+  tabSize = 2,
+  fontSize = 14,
+  placeholder,
+  fileName,
+  className,
+  onMount
+}) => {
+  const textareaRef = (0, import_react2.useRef)(null);
+  const lineCountRef = (0, import_react2.useRef)(null);
+  const [lineCount, setLineCount] = (0, import_react2.useState)(1);
+  const [cursorInfo, setCursorInfo] = (0, import_react2.useState)({ line: 1, col: 1 });
+  (0, import_react2.useEffect)(() => {
+    const count = (value || "").split("\n").length;
+    setLineCount(count);
+  }, [value]);
+  (0, import_react2.useEffect)(() => {
+    if (textareaRef.current && onMount) {
+      onMount(textareaRef.current);
+    }
+  }, [onMount]);
+  const handleChange = (0, import_react2.useCallback)(
+    (e) => {
+      onChange?.(e.target.value);
+    },
+    [onChange]
+  );
+  const handleKeyDown = (0, import_react2.useCallback)(
+    (e) => {
+      if (e.key === "Tab") {
+        e.preventDefault();
+        const textarea = e.currentTarget;
+        const start = textarea.selectionStart;
+        const end = textarea.selectionEnd;
+        const spaces = " ".repeat(tabSize);
+        const newValue = value.substring(0, start) + spaces + value.substring(end);
+        onChange?.(newValue);
+        requestAnimationFrame(() => {
+          textarea.selectionStart = textarea.selectionEnd = start + tabSize;
+        });
+      }
+    },
+    [value, onChange, tabSize]
+  );
+  const handleSelect = (0, import_react2.useCallback)(() => {
+    if (!textareaRef.current) return;
+    const pos = textareaRef.current.selectionStart;
+    const textBefore = value.substring(0, pos);
+    const line = textBefore.split("\n").length;
+    const col = pos - textBefore.lastIndexOf("\n");
+    setCursorInfo({ line, col });
+  }, [value]);
+  const handleScroll = (0, import_react2.useCallback)(() => {
+    if (textareaRef.current && lineCountRef.current) {
+      lineCountRef.current.scrollTop = textareaRef.current.scrollTop;
+    }
+  }, []);
+  const heightStyle = typeof height === "number" ? `${height}px` : height;
+  const cls = ["code-editor", "code-editor--legacy", className].filter(Boolean).join(" ");
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: cls, style: { "--editor-height": heightStyle, "--editor-font-size": `${fontSize}px` }, children: [
+    fileName && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "code-editor__header", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "code-editor__filename", children: fileName }),
+      language && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "code-editor__badge", children: language })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "code-editor__body", children: [
+      lineNumbers && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "code-editor__gutter", ref: lineCountRef, "aria-hidden": "true", children: Array.from({ length: lineCount }, (_, i) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "code-editor__line-number", children: i + 1 }, i)) }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+        "textarea",
+        {
+          ref: textareaRef,
+          className: "code-editor__textarea",
+          value,
+          onChange: handleChange,
+          onKeyDown: handleKeyDown,
+          onSelect: handleSelect,
+          onScroll: handleScroll,
+          readOnly,
+          placeholder,
+          spellCheck: false,
+          autoCapitalize: "off",
+          autoComplete: "off",
+          autoCorrect: "off",
+          "data-language": language
+        }
+      )
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "code-editor__footer", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { className: "code-editor__cursor-info", children: [
+        "Ln ",
+        cursorInfo.line,
+        ", Col ",
+        cursorInfo.col
+      ] }),
+      language && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "code-editor__language", children: language }),
+      readOnly && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "code-editor__readonly", children: "Read Only" })
+    ] })
+  ] });
+};
+
+// src/CodeEditor/useMonacoTheme.ts
+var import_react3 = require("react");
+var import_react4 = require("@monaco-editor/react");
+var import_theme = require("@orchestra-mcp/theme");
+
+// src/CodeEditor/theme-bridge.ts
+function orchestraToMonacoTheme(theme) {
+  return {
+    base: theme.isLight ? "vs" : "vs-dark",
+    inherit: true,
+    rules: buildTokenRules(theme.syntax),
+    colors: buildEditorColors(theme.colors)
+  };
+}
+function buildTokenRules(s) {
+  return [
+    { token: "keyword", foreground: strip(s.purple) },
+    { token: "keyword.control", foreground: strip(s.purple) },
+    { token: "storage.type", foreground: strip(s.purple) },
+    { token: "string", foreground: strip(s.green) },
+    { token: "string.quoted", foreground: strip(s.green) },
+    { token: "string.escape", foreground: strip(s.orange) },
+    { token: "constant.numeric", foreground: strip(s.orange) },
+    { token: "constant.language", foreground: strip(s.orange) },
+    { token: "number", foreground: strip(s.orange) },
+    { token: "entity.name.function", foreground: strip(s.blue) },
+    { token: "support.function", foreground: strip(s.blue) },
+    { token: "variable.parameter", foreground: strip(s.cyan) },
+    { token: "punctuation", foreground: strip(s.cyan) },
+    { token: "delimiter", foreground: strip(s.cyan) },
+    { token: "entity.name.type", foreground: strip(s.yellow) },
+    { token: "entity.name.class", foreground: strip(s.yellow) },
+    { token: "support.type", foreground: strip(s.yellow) },
+    { token: "type", foreground: strip(s.yellow) },
+    { token: "attribute.name", foreground: strip(s.yellow) },
+    { token: "attribute.value", foreground: strip(s.green) },
+    { token: "tag", foreground: strip(s.red) },
+    { token: "invalid", foreground: strip(s.red) },
+    { token: "invalid.illegal", foreground: strip(s.red) },
+    { token: "variable.language", foreground: strip(s.red) },
+    { token: "regexp", foreground: strip(s.red) },
+    { token: "comment", foreground: strip(s.teal), fontStyle: "italic" },
+    { token: "entity.other.attribute-name", foreground: strip(s.teal) },
+    { token: "invalid.deprecated", foreground: strip(s.error) }
+  ];
+}
+function buildEditorColors(c) {
+  return {
+    "editor.background": c.bg,
+    "editor.foreground": c.fg,
+    "editor.lineHighlightBackground": c.bgActive,
+    "editor.selectionBackground": c.bgSelection,
+    "editorCursor.foreground": c.accent,
+    "editorLineNumber.foreground": c.fgMuted,
+    "editorLineNumber.activeForeground": c.fgBright,
+    "editorGutter.background": c.bgAlt,
+    "editorWidget.background": c.bgAlt,
+    "editorWidget.border": c.border,
+    "editorGroup.border": c.border,
+    "focusBorder": c.accent,
+    "input.background": c.bgContrast,
+    "input.foreground": c.fg,
+    "input.border": c.border,
+    "dropdown.background": c.bgAlt,
+    "dropdown.border": c.border,
+    "list.hoverBackground": c.bgActive,
+    "list.activeSelectionBackground": c.bgSelection,
+    "minimap.background": c.bgAlt,
+    "scrollbarSlider.background": c.bgActive + "80",
+    "scrollbarSlider.hoverBackground": c.bgActive
+  };
+}
+function strip(hex) {
+  return hex.replace(/^#/, "");
+}
+function getMonacoThemeId(orchestraId) {
+  return `orchestra-${orchestraId}`;
+}
+
+// src/CodeEditor/useMonacoTheme.ts
+function useMonacoTheme(overrideTheme) {
+  const monaco = (0, import_react4.useMonaco)();
+  const registered = (0, import_react3.useRef)(false);
+  const [themeId, setThemeId] = (0, import_react3.useState)(
+    () => overrideTheme ?? getMonacoThemeId((0, import_theme.getColorTheme)())
+  );
+  (0, import_react3.useEffect)(() => {
+    if (!monaco || registered.current) return;
+    registered.current = true;
+    for (const theme of import_theme.THEMES) {
+      monaco.editor.defineTheme(
+        getMonacoThemeId(theme.id),
+        orchestraToMonacoTheme(theme)
+      );
+    }
+    const currentId = overrideTheme ?? getMonacoThemeId((0, import_theme.getColorTheme)());
+    monaco.editor.setTheme(currentId);
+    setThemeId(currentId);
+  }, [monaco, overrideTheme]);
+  (0, import_react3.useEffect)(() => {
+    if (overrideTheme || !monaco) return;
+    const unsubscribe = (0, import_theme.onColorThemeChange)((newId) => {
+      const monacoId = getMonacoThemeId(newId);
+      monaco.editor.setTheme(monacoId);
+      setThemeId(monacoId);
+    });
+    return unsubscribe;
+  }, [monaco, overrideTheme]);
+  return themeId;
+}
+
+// src/CodeEditor/useMonacoKeybindings.ts
+var import_react5 = require("react");
+
+// src/CodeEditor/jetbrains-keymap.ts
+var JETBRAINS_KEYMAP = [
+  {
+    id: "jb-duplicate-line",
+    label: "Duplicate Line",
+    keybinding: (KM, KC) => KM.CtrlCmd | KC.KeyD,
+    run: (ed) => {
+      ed.getAction("editor.action.copyLinesDownAction")?.run();
+    }
+  },
+  {
+    id: "jb-delete-line",
+    label: "Delete Line",
+    keybinding: (KM, KC) => KM.CtrlCmd | KC.KeyY,
+    run: (ed) => {
+      ed.getAction("editor.action.deleteLines")?.run();
+    }
+  },
+  {
+    id: "jb-move-line-up",
+    label: "Move Line Up",
+    keybinding: (KM, KC) => KM.CtrlCmd | KM.Shift | KC.UpArrow,
+    run: (ed) => {
+      ed.getAction("editor.action.moveLinesUpAction")?.run();
+    }
+  },
+  {
+    id: "jb-move-line-down",
+    label: "Move Line Down",
+    keybinding: (KM, KC) => KM.CtrlCmd | KM.Shift | KC.DownArrow,
+    run: (ed) => {
+      ed.getAction("editor.action.moveLinesDownAction")?.run();
+    }
+  },
+  {
+    id: "jb-toggle-comment",
+    label: "Toggle Line Comment",
+    keybinding: (KM, KC) => KM.CtrlCmd | KC.Slash,
+    run: (ed) => {
+      ed.getAction("editor.action.commentLine")?.run();
+    }
+  },
+  {
+    id: "jb-block-comment",
+    label: "Toggle Block Comment",
+    keybinding: (KM, KC) => KM.CtrlCmd | KM.Shift | KC.Slash,
+    run: (ed) => {
+      ed.getAction("editor.action.blockComment")?.run();
+    }
+  },
+  {
+    id: "jb-format",
+    label: "Reformat Code",
+    keybinding: (KM, KC) => KM.CtrlCmd | KM.Alt | KC.KeyL,
+    run: (ed) => {
+      ed.getAction("editor.action.formatDocument")?.run();
+    }
+  },
+  {
+    id: "jb-quick-fix",
+    label: "Show Quick Fixes",
+    keybinding: (KM, KC) => KM.Alt | KC.Enter,
+    run: (ed) => {
+      ed.getAction("editor.action.quickFix")?.run();
+    }
+  },
+  {
+    id: "jb-go-to-declaration",
+    label: "Go to Declaration",
+    keybinding: (KM, KC) => KM.CtrlCmd | KC.KeyB,
+    run: (ed) => {
+      ed.getAction("editor.action.revealDefinition")?.run();
+    }
+  },
+  {
+    id: "jb-complete-statement",
+    label: "Complete Statement",
+    keybinding: (KM, KC) => KM.CtrlCmd | KM.Shift | KC.Enter,
+    run: (ed) => {
+      ed.getAction("editor.action.insertLineAfter")?.run();
+    }
+  },
+  {
+    id: "jb-select-word",
+    label: "Extend Selection",
+    keybinding: (KM, KC) => KM.CtrlCmd | KC.KeyW,
+    run: (ed) => {
+      ed.getAction("editor.action.smartSelect.expand")?.run();
+    }
+  },
+  {
+    id: "jb-shrink-selection",
+    label: "Shrink Selection",
+    keybinding: (KM, KC) => KM.CtrlCmd | KM.Shift | KC.KeyW,
+    run: (ed) => {
+      ed.getAction("editor.action.smartSelect.shrink")?.run();
+    }
+  }
+];
+function applyJetBrainsKeymap(editor, monaco) {
+  for (const kb of JETBRAINS_KEYMAP) {
+    editor.addAction({
+      id: kb.id,
+      label: kb.label,
+      keybindings: [kb.keybinding(monaco.KeyMod, monaco.KeyCode)],
+      run: kb.run
+    });
+  }
+}
+
+// src/CodeEditor/useMonacoKeybindings.ts
+function useMonacoKeybindings(editor, monaco, keymap) {
+  (0, import_react5.useEffect)(() => {
+    if (!editor || !monaco || !keymap || keymap === "default") return;
+    if (keymap === "jetbrains") {
+      applyJetBrainsKeymap(editor, monaco);
+      return;
+    }
+    if (Array.isArray(keymap)) {
+      for (const entry of keymap) {
+        editor.addAction({
+          id: entry.id,
+          label: entry.label,
+          keybindings: [entry.keybinding],
+          run: entry.handler
+        });
+      }
+    }
+  }, [editor, monaco, keymap]);
+}
+
+// src/CodeEditor/useLsp.ts
+var import_react6 = require("react");
+var RECONNECT_DELAY = 3e3;
+var MAX_RETRIES = 3;
+function useLsp({
+  monaco,
+  editor,
+  languageId,
+  lspUrl,
+  onStatusChange
+}) {
+  const [status, setStatus] = (0, import_react6.useState)("disconnected");
+  const connectionRef = (0, import_react6.useRef)(null);
+  const retriesRef = (0, import_react6.useRef)(0);
+  const timerRef = (0, import_react6.useRef)(null);
+  const updateStatus = (0, import_react6.useCallback)(
+    (next) => {
+      setStatus(next);
+      onStatusChange?.(next);
+    },
+    [onStatusChange]
+  );
+  const disconnect = (0, import_react6.useCallback)(() => {
+    if (timerRef.current) {
+      clearTimeout(timerRef.current);
+      timerRef.current = null;
+    }
+    if (connectionRef.current) {
+      connectionRef.current.dispose();
+      connectionRef.current = null;
+    }
+  }, []);
+  const connect = (0, import_react6.useCallback)(async () => {
+    if (!monaco || !editor || !languageId || !lspUrl) return;
+    disconnect();
+    updateStatus("connecting");
+    try {
+      const { connectLanguageServer: connectLanguageServer2 } = await Promise.resolve().then(() => (init_lsp_bridge(), lsp_bridge_exports));
+      const conn = await connectLanguageServer2(monaco, editor, languageId, lspUrl);
+      connectionRef.current = conn;
+      retriesRef.current = 0;
+      updateStatus("connected");
+    } catch {
+      updateStatus("error");
+      if (retriesRef.current < MAX_RETRIES) {
+        retriesRef.current += 1;
+        timerRef.current = setTimeout(() => connect(), RECONNECT_DELAY);
+      }
+    }
+  }, [monaco, editor, languageId, lspUrl, disconnect, updateStatus]);
+  const reconnect = (0, import_react6.useCallback)(() => {
+    retriesRef.current = 0;
+    connect();
+  }, [connect]);
+  (0, import_react6.useEffect)(() => {
+    if (monaco && editor && languageId && lspUrl) {
+      connect();
+    }
+    return () => disconnect();
+  }, [monaco, editor, languageId, lspUrl, connect, disconnect]);
+  return { status, reconnect };
+}
+
+// src/CodeEditor/language-map.ts
+var LANGUAGE_MAP = {
+  // Monaco built-in language IDs
+  javascript: "javascript",
+  typescript: "typescript",
+  html: "html",
+  css: "css",
+  json: "json",
+  python: "python",
+  go: "go",
+  rust: "rust",
+  java: "java",
+  csharp: "csharp",
+  cpp: "cpp",
+  c: "c",
+  php: "php",
+  ruby: "ruby",
+  swift: "swift",
+  kotlin: "kotlin",
+  sql: "sql",
+  yaml: "yaml",
+  xml: "xml",
+  markdown: "markdown",
+  shell: "shell",
+  scss: "scss",
+  less: "less",
+  graphql: "graphql",
+  dockerfile: "dockerfile",
+  lua: "lua",
+  perl: "perl",
+  r: "r",
+  // Common aliases
+  ts: "typescript",
+  tsx: "typescript",
+  js: "javascript",
+  jsx: "javascript",
+  py: "python",
+  rs: "rust",
+  rb: "ruby",
+  cs: "csharp",
+  kt: "kotlin",
+  md: "markdown",
+  yml: "yaml",
+  bash: "shell",
+  sh: "shell",
+  zsh: "shell",
+  toml: "ini",
+  proto: "protobuf",
+  tf: "hcl"
+};
+function resolveLanguage(lang) {
+  if (!lang) return void 0;
+  return LANGUAGE_MAP[lang.toLowerCase()] ?? lang.toLowerCase();
+}
+function languageFromFilename(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase();
+  if (!ext) return void 0;
+  return LANGUAGE_MAP[ext];
+}
+
+// src/CodeEditor/CodeEditor.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+function MonacoCodeEditor(props) {
+  const {
+    value,
+    language,
+    onChange,
+    readOnly = false,
+    lineNumbers = true,
+    minimap = false,
+    wordWrap = "off",
+    height = 400,
+    tabSize = 2,
+    fontSize = 14,
+    fileName,
+    className,
+    onMount,
+    beforeMount,
+    options,
+    keymap,
+    lspUrl,
+    onLspStatusChange,
+    theme: themeOverride,
+    loading
+  } = props;
+  const editorRef = (0, import_react7.useRef)(null);
+  const monacoRef = (0, import_react7.useRef)(null);
+  const [cursorInfo, setCursorInfo] = (0, import_react7.useState)({ line: 1, col: 1 });
+  const monacoTheme = useMonacoTheme(themeOverride);
+  useMonacoKeybindings(editorRef.current, monacoRef.current, keymap);
+  const resolvedLang = language ? resolveLanguage(language) : fileName ? languageFromFilename(fileName) : void 0;
+  const { status: lspStatus } = useLsp({
+    monaco: monacoRef.current,
+    editor: editorRef.current,
+    languageId: resolvedLang,
+    lspUrl,
+    onStatusChange: onLspStatusChange
+  });
+  const handleMount = (0, import_react7.useCallback)(
+    (editor, monaco) => {
+      editorRef.current = editor;
+      monacoRef.current = monaco;
+      editor.onDidChangeCursorPosition((e) => {
+        setCursorInfo({ line: e.position.lineNumber, col: e.position.column });
+      });
+      onMount?.(editor, monaco);
+    },
+    [onMount]
+  );
+  const handleChange = (0, import_react7.useCallback)(
+    (val) => {
+      onChange?.(val ?? "");
+    },
+    [onChange]
+  );
+  const heightStyle = typeof height === "number" ? `${height}px` : height;
+  const cls = ["code-editor", className].filter(Boolean).join(" ");
+  const mergedOptions = {
+    readOnly,
+    lineNumbers: lineNumbers ? "on" : "off",
+    minimap: { enabled: minimap },
+    wordWrap,
+    tabSize,
+    fontSize,
+    scrollBeyondLastLine: false,
+    automaticLayout: true,
+    padding: { top: 8, bottom: 8 },
+    contextmenu: true,
+    find: { addExtraSpaceOnTop: false, autoFindInSelection: "multiline" },
+    suggest: { showMethods: true, showFunctions: true, showSnippets: true },
+    ...options
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: cls, children: [
+    fileName && /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: "code-editor__header", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "code-editor__filename", children: fileName }),
+      resolvedLang && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "code-editor__badge", children: resolvedLang })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(MonacoSuspense, { loading, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      MonacoEditor,
+      {
+        height: heightStyle,
+        language: resolvedLang,
+        value,
+        theme: monacoTheme,
+        options: mergedOptions,
+        onChange: handleChange,
+        onMount: handleMount,
+        beforeMount
+      }
+    ) }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: "code-editor__footer", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("span", { className: "code-editor__cursor-info", children: [
+        "Ln ",
+        cursorInfo.line,
+        ", Col ",
+        cursorInfo.col
+      ] }),
+      resolvedLang && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "code-editor__language", children: resolvedLang }),
+      readOnly && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "code-editor__readonly", children: "Read Only" }),
+      lspUrl && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: `code-editor__lsp code-editor__lsp--${lspStatus}`, children: lspStatus === "connected" ? "LSP" : lspStatus === "connecting" ? "LSP..." : lspStatus === "error" ? "LSP \u2717" : "" })
+    ] })
+  ] });
+}
+var CodeEditor = (props) => {
+  if (props.useLegacy) {
+    const {
+      onMount: _onMount,
+      beforeMount: _beforeMount,
+      options: _options,
+      keymap: _keymap,
+      lspUrl: _lspUrl,
+      onLspStatusChange: _onLspStatusChange,
+      theme: _theme,
+      loading: _loading,
+      useLegacy: _,
+      ...legacyProps
+    } = props;
+    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(LegacyCodeEditor, { ...legacyProps });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(MonacoCodeEditor, { ...props });
+};
+
+// src/CodeEditor/CodeDiffEditor.tsx
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var CodeDiffEditor = ({
+  original,
+  modified,
+  language,
+  fileName,
+  height = 300,
+  readOnly = true,
+  renderSideBySide = false,
+  className,
+  loading
+}) => {
+  const monacoTheme = useMonacoTheme();
+  const resolvedLang = language ? resolveLanguage(language) : fileName ? languageFromFilename(fileName) : void 0;
+  const heightStyle = typeof height === "number" ? `${height}px` : height;
+  const cls = ["code-editor", className].filter(Boolean).join(" ");
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { className: cls, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(MonacoSuspense, { loading, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+    MonacoDiffEditor,
+    {
+      height: heightStyle,
+      language: resolvedLang,
+      original,
+      modified,
+      theme: monacoTheme,
+      options: {
+        readOnly,
+        renderSideBySide,
+        minimap: { enabled: false },
+        scrollBeyondLastLine: false,
+        lineNumbers: "on",
+        automaticLayout: true,
+        padding: { top: 8, bottom: 8 }
+      }
+    }
+  ) }) });
+};
+
+// src/CodeBlock/CodeBlock.tsx
+var import_react8 = require("react");
+var import_widgets2 = require("@orchestra-mcp/widgets");
+
+// src/CodeBlock/highlighter.ts
+var COMMON_KEYWORDS = [
+  "if",
+  "else",
+  "for",
+  "while",
+  "return",
+  "function",
+  "class",
+  "const",
+  "let",
+  "var",
+  "import",
+  "export",
+  "from",
+  "default",
+  "new",
+  "this",
+  "throw",
+  "try",
+  "catch",
+  "finally",
+  "switch",
+  "case",
+  "break",
+  "continue",
+  "do",
+  "in",
+  "of",
+  "typeof",
+  "instanceof",
+  "void",
+  "delete",
+  "async",
+  "await",
+  "yield",
+  "static",
+  "extends",
+  "super",
+  "implements",
+  "interface",
+  "type",
+  "enum",
+  "abstract",
+  "readonly"
+];
+var PHP_KEYWORDS = [
+  "namespace",
+  "use",
+  "class",
+  "function",
+  "public",
+  "private",
+  "protected",
+  "static",
+  "return",
+  "if",
+  "else",
+  "foreach",
+  "as",
+  "new",
+  "extends",
+  "implements",
+  "interface",
+  "abstract",
+  "final",
+  "const",
+  "echo",
+  "throw",
+  "try",
+  "catch",
+  "finally",
+  "match",
+  "fn",
+  "yield",
+  "readonly"
+];
+var GO_KEYWORDS = [
+  "func",
+  "package",
+  "import",
+  "type",
+  "struct",
+  "interface",
+  "map",
+  "chan",
+  "go",
+  "defer",
+  "return",
+  "if",
+  "else",
+  "for",
+  "range",
+  "switch",
+  "case",
+  "default",
+  "break",
+  "continue",
+  "select",
+  "var",
+  "const",
+  "fallthrough",
+  "goto"
+];
+var RUST_KEYWORDS = [
+  "fn",
+  "let",
+  "mut",
+  "pub",
+  "struct",
+  "enum",
+  "impl",
+  "trait",
+  "use",
+  "mod",
+  "crate",
+  "self",
+  "super",
+  "match",
+  "if",
+  "else",
+  "for",
+  "while",
+  "loop",
+  "return",
+  "where",
+  "async",
+  "await",
+  "move",
+  "ref",
+  "type",
+  "const",
+  "static",
+  "unsafe",
+  "extern",
+  "dyn",
+  "as",
+  "in"
+];
+var PYTHON_KEYWORDS = [
+  "def",
+  "class",
+  "import",
+  "from",
+  "return",
+  "if",
+  "elif",
+  "else",
+  "for",
+  "while",
+  "in",
+  "not",
+  "and",
+  "or",
+  "is",
+  "with",
+  "as",
+  "try",
+  "except",
+  "finally",
+  "raise",
+  "pass",
+  "break",
+  "continue",
+  "lambda",
+  "yield",
+  "global",
+  "nonlocal",
+  "assert",
+  "del",
+  "async",
+  "await"
+];
+var JAVA_KEYWORDS = [
+  "class",
+  "interface",
+  "extends",
+  "implements",
+  "public",
+  "private",
+  "protected",
+  "static",
+  "final",
+  "abstract",
+  "void",
+  "return",
+  "if",
+  "else",
+  "for",
+  "while",
+  "do",
+  "switch",
+  "case",
+  "break",
+  "continue",
+  "new",
+  "throw",
+  "try",
+  "catch",
+  "finally",
+  "import",
+  "package",
+  "this",
+  "super",
+  "synchronized",
+  "volatile"
+];
+var C_KEYWORDS = [
+  "if",
+  "else",
+  "for",
+  "while",
+  "do",
+  "switch",
+  "case",
+  "break",
+  "continue",
+  "return",
+  "struct",
+  "typedef",
+  "enum",
+  "union",
+  "void",
+  "int",
+  "char",
+  "float",
+  "double",
+  "long",
+  "short",
+  "unsigned",
+  "signed",
+  "const",
+  "static",
+  "extern",
+  "sizeof",
+  "include",
+  "define",
+  "ifdef",
+  "ifndef",
+  "endif",
+  "NULL"
+];
+var RUBY_KEYWORDS = [
+  "def",
+  "class",
+  "module",
+  "end",
+  "if",
+  "elsif",
+  "else",
+  "unless",
+  "while",
+  "until",
+  "for",
+  "do",
+  "begin",
+  "rescue",
+  "ensure",
+  "raise",
+  "return",
+  "yield",
+  "block_given",
+  "require",
+  "include",
+  "extend",
+  "attr_accessor",
+  "attr_reader",
+  "nil",
+  "true",
+  "false",
+  "self",
+  "super",
+  "puts",
+  "print"
+];
+var BASH_KEYWORDS = [
+  "if",
+  "then",
+  "else",
+  "elif",
+  "fi",
+  "for",
+  "while",
+  "do",
+  "done",
+  "case",
+  "esac",
+  "function",
+  "return",
+  "exit",
+  "echo",
+  "read",
+  "export",
+  "source",
+  "local",
+  "readonly",
+  "shift",
+  "set",
+  "unset",
+  "trap",
+  "eval",
+  "exec",
+  "cd",
+  "pwd",
+  "test",
+  "true",
+  "false"
+];
+var SQL_KEYWORDS = [
+  "SELECT",
+  "FROM",
+  "WHERE",
+  "INSERT",
+  "INTO",
+  "VALUES",
+  "UPDATE",
+  "SET",
+  "DELETE",
+  "CREATE",
+  "TABLE",
+  "ALTER",
+  "DROP",
+  "INDEX",
+  "JOIN",
+  "LEFT",
+  "RIGHT",
+  "INNER",
+  "OUTER",
+  "ON",
+  "AND",
+  "OR",
+  "NOT",
+  "NULL",
+  "AS",
+  "ORDER",
+  "BY",
+  "GROUP",
+  "HAVING",
+  "LIMIT",
+  "OFFSET",
+  "DISTINCT",
+  "UNION",
+  "EXISTS",
+  "IN",
+  "BETWEEN",
+  "LIKE",
+  "IS",
+  "PRIMARY",
+  "KEY",
+  "FOREIGN",
+  "REFERENCES",
+  "CASCADE",
+  "DEFAULT",
+  "CONSTRAINT",
+  "BEGIN",
+  "COMMIT",
+  "ROLLBACK"
+];
+var SWIFT_KEYWORDS = [
+  "func",
+  "var",
+  "let",
+  "class",
+  "struct",
+  "enum",
+  "protocol",
+  "extension",
+  "import",
+  "return",
+  "if",
+  "else",
+  "guard",
+  "switch",
+  "case",
+  "default",
+  "for",
+  "while",
+  "repeat",
+  "break",
+  "continue",
+  "throw",
+  "try",
+  "catch",
+  "self",
+  "super",
+  "init",
+  "deinit",
+  "nil",
+  "true",
+  "false",
+  "override",
+  "private",
+  "public",
+  "internal",
+  "open",
+  "static",
+  "async",
+  "await"
+];
+var KOTLIN_KEYWORDS = [
+  "fun",
+  "val",
+  "var",
+  "class",
+  "object",
+  "interface",
+  "abstract",
+  "override",
+  "open",
+  "data",
+  "sealed",
+  "import",
+  "package",
+  "return",
+  "if",
+  "else",
+  "when",
+  "for",
+  "while",
+  "do",
+  "break",
+  "continue",
+  "throw",
+  "try",
+  "catch",
+  "finally",
+  "this",
+  "super",
+  "null",
+  "true",
+  "false",
+  "is",
+  "as",
+  "in",
+  "suspend",
+  "companion",
+  "init",
+  "private",
+  "public",
+  "internal",
+  "protected"
+];
+var CSHARP_KEYWORDS = [
+  "class",
+  "interface",
+  "struct",
+  "enum",
+  "namespace",
+  "using",
+  "public",
+  "private",
+  "protected",
+  "internal",
+  "static",
+  "void",
+  "return",
+  "if",
+  "else",
+  "for",
+  "foreach",
+  "while",
+  "do",
+  "switch",
+  "case",
+  "break",
+  "continue",
+  "new",
+  "throw",
+  "try",
+  "catch",
+  "finally",
+  "async",
+  "await",
+  "var",
+  "const",
+  "readonly",
+  "override",
+  "virtual",
+  "abstract",
+  "sealed",
+  "partial",
+  "this",
+  "base",
+  "null",
+  "true",
+  "false",
+  "out",
+  "ref",
+  "in",
+  "yield"
+];
+function getKeywords(lang) {
+  switch (lang) {
+    case "php":
+      return PHP_KEYWORDS;
+    case "go":
+    case "golang":
+      return GO_KEYWORDS;
+    case "rust":
+    case "rs":
+      return RUST_KEYWORDS;
+    case "python":
+    case "py":
+      return PYTHON_KEYWORDS;
+    case "java":
+      return JAVA_KEYWORDS;
+    case "c":
+    case "cpp":
+    case "c++":
+    case "h":
+      return C_KEYWORDS;
+    case "ruby":
+    case "rb":
+      return RUBY_KEYWORDS;
+    case "bash":
+    case "sh":
+    case "shell":
+    case "zsh":
+      return BASH_KEYWORDS;
+    case "sql":
+    case "mysql":
+    case "postgresql":
+    case "postgres":
+    case "sqlite":
+      return SQL_KEYWORDS;
+    case "swift":
+      return SWIFT_KEYWORDS;
+    case "kotlin":
+    case "kt":
+      return KOTLIN_KEYWORDS;
+    case "csharp":
+    case "cs":
+    case "c#":
+      return CSHARP_KEYWORDS;
+    default:
+      return COMMON_KEYWORDS;
+  }
+}
+function buildRules(lang) {
+  const keywords = getKeywords(lang);
+  const isSql = lang === "sql" || lang === "mysql" || lang === "postgresql" || lang === "postgres" || lang === "sqlite";
+  const kwFlags = isSql ? "gi" : "g";
+  const kwPattern = new RegExp(`\\b(${keywords.join("|")})\\b`, kwFlags);
+  const hasDollarVars = lang === "php" || lang === "bash" || lang === "sh" || lang === "shell" || lang === "zsh";
+  return [
+    // Comments: // and # single-line
+    { pattern: /\/\/.*$/gm, className: "syn-comment" },
+    { pattern: /#.*$/gm, className: "syn-comment" },
+    // Multi-line comments
+    { pattern: /\/\*[\s\S]*?\*\//g, className: "syn-comment" },
+    // SQL single-line comments (--)
+    ...isSql ? [{ pattern: /--.*$/gm, className: "syn-comment" }] : [],
+    // Strings: double-quoted
+    { pattern: /"(?:[^"\\]|\\.)*"/g, className: "syn-string" },
+    // Strings: single-quoted
+    { pattern: /'(?:[^'\\]|\\.)*'/g, className: "syn-string" },
+    // Strings: backtick
+    { pattern: /`(?:[^`\\]|\\.)*`/g, className: "syn-string" },
+    // Numbers
+    { pattern: /\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/gi, className: "syn-number" },
+    // PHP/Bash variables
+    ...hasDollarVars ? [{ pattern: /\$[a-zA-Z_]\w*/g, className: "syn-variable" }] : [],
+    // Type names (PascalCase)
+    { pattern: /\b[A-Z][a-zA-Z0-9_]*\b/g, className: "syn-type" },
+    // Keywords
+    { pattern: kwPattern, className: "syn-keyword" },
+    // Punctuation: arrows, operators
+    { pattern: /=>|->|::|\.\.\.|\.\.|[{}()[\];,.:?]/g, className: "syn-punctuation" }
+  ];
+}
+function tokenizeLine(line, lang) {
+  const rules = buildRules(lang);
+  const markers = [];
+  for (const rule of rules) {
+    rule.pattern.lastIndex = 0;
+    let match;
+    while ((match = rule.pattern.exec(line)) !== null) {
+      markers.push({
+        start: match.index,
+        end: match.index + match[0].length,
+        className: rule.className
+      });
+    }
+  }
+  markers.sort((a, b) => a.start - b.start || b.end - b.start - (a.end - a.start));
+  const resolved = [];
+  let cursor = 0;
+  for (const m of markers) {
+    if (m.start >= cursor) {
+      resolved.push(m);
+      cursor = m.end;
+    }
+  }
+  const tokens = [];
+  let pos = 0;
+  for (const m of resolved) {
+    if (m.start > pos) {
+      tokens.push({ text: line.slice(pos, m.start), start: pos, end: m.start });
+    }
+    tokens.push({
+      text: line.slice(m.start, m.end),
+      className: m.className,
+      start: m.start,
+      end: m.end
+    });
+    pos = m.end;
+  }
+  if (pos < line.length) {
+    tokens.push({ text: line.slice(pos), start: pos, end: line.length });
+  }
+  return tokens.length > 0 ? tokens : [{ text: line || "\n", start: 0, end: line.length }];
+}
+
+// src/CodeBlock/CodeBlock.tsx
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var LANGUAGE_EXTENSIONS = {
+  javascript: "js",
+  typescript: "ts",
+  python: "py",
+  ruby: "rb",
+  rust: "rs",
+  go: "go",
+  java: "java",
+  css: "css",
+  html: "html",
+  json: "json",
+  yaml: "yml",
+  bash: "sh",
+  shell: "sh",
+  sql: "sql",
+  markdown: "md",
+  php: "php",
+  csharp: "cs",
+  swift: "swift",
+  kotlin: "kt"
+};
+var WrapIcon = () => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("path", { d: "M2 4h12M2 8h8a2 2 0 0 1 0 4H8l1.5-1.5M9.5 12L8 10.5", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round" }) });
+var CopyIcon = () => /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: [
+  /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("rect", { x: "5", y: "5", width: "8", height: "8", rx: "1.5", stroke: "currentColor", strokeWidth: "1.5" }),
+  /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("path", { d: "M11 3H4.5A1.5 1.5 0 0 0 3 4.5V11", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round" })
+] });
+var CheckIcon = () => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("path", { d: "M3.5 8.5L6.5 11.5L12.5 4.5", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round" }) });
+var DownloadIcon = () => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("path", { d: "M8 2v8m0 0L5 7m3 3l3-3M3 12h10", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round" }) });
+var ImageIcon = () => /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: [
+  /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("rect", { x: "2", y: "2", width: "12", height: "12", rx: "2", stroke: "currentColor", strokeWidth: "1.5" }),
+  /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("circle", { cx: "6", cy: "6", r: "1.5", fill: "currentColor" }),
+  /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("path", { d: "M2 11l3-3 2 2 3-3 4 4", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round" })
+] });
+var MermaidIcon = () => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("path", { d: "M8 2v4M8 6L4 10M8 6l4 4M4 10v2M8 10v2M12 10v2", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round" }) });
+var CodeBlock = ({
+  code,
+  language,
+  showLineNumbers = false,
+  highlightLines = [],
+  copyable = true,
+  exportable = false,
+  exportImage = false,
+  filename,
+  maxHeight,
+  wrapLines = false,
+  showWindowDots = true,
+  onConvertToMermaid,
+  className
+}) => {
+  const [copied, setCopied] = (0, import_react8.useState)(false);
+  const [wrapped, setWrapped] = (0, import_react8.useState)(wrapLines);
+  const timerRef = (0, import_react8.useRef)(null);
+  const blockRef = (0, import_react8.useRef)(null);
+  const lines = code.split("\n");
+  const highlightSet = new Set(highlightLines);
+  const handleCopy = (0, import_react8.useCallback)(() => {
+    navigator.clipboard.writeText(code).then(() => {
+      setCopied(true);
+      if (timerRef.current) clearTimeout(timerRef.current);
+      timerRef.current = setTimeout(() => setCopied(false), 2e3);
+    });
+  }, [code]);
+  const handleExport = (0, import_react8.useCallback)(async () => {
+    const ext = language ? LANGUAGE_EXTENSIONS[language] ?? language : "txt";
+    const base = filename ?? "code";
+    const name = (0, import_widgets2.uuidFilename)(base, ext);
+    await (0, import_widgets2.saveFile)(code, name, "text/plain");
+  }, [code, language, filename]);
+  const handleExportImage = (0, import_react8.useCallback)(async () => {
+    if (!blockRef.current) return;
+    const { exportToImage: exportToImage2 } = await Promise.resolve().then(() => (init_exportToImage(), exportToImage_exports));
+    const name = filename ?? `code-${language ?? "snippet"}`;
+    await exportToImage2(blockRef.current, name);
+  }, [filename, language]);
+  const handleToggleWrap = (0, import_react8.useCallback)(() => {
+    setWrapped((prev) => !prev);
+  }, []);
+  const showHeader = language || copyable || exportable || exportImage;
+  const bodyStyle = maxHeight ? { maxHeight: `${maxHeight}px` } : void 0;
+  const wrapperClass = ["code-block", className].filter(Boolean).join(" ");
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { className: wrapperClass, ref: blockRef, children: [
+    showHeader && /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { className: "code-block__header", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { className: "code-block__header-left", children: [
+        showWindowDots && /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { className: "code-block__dots", "aria-hidden": "true", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("span", { className: "code-block__dot code-block__dot--red" }),
+          /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("span", { className: "code-block__dot code-block__dot--yellow" }),
+          /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("span", { className: "code-block__dot code-block__dot--green" })
+        ] }),
+        language && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("span", { className: "code-block__badge", children: language })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { className: "code-block__actions", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+          "button",
+          {
+            type: "button",
+            className: "code-block__btn",
+            onClick: handleToggleWrap,
+            title: wrapped ? "Disable word wrap" : "Enable word wrap",
+            "aria-label": "Toggle word wrap",
+            children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(WrapIcon, {})
+          }
+        ),
+        copyable && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+          "button",
+          {
+            type: "button",
+            className: `code-block__btn ${copied ? "code-block__btn--copied" : ""}`,
+            onClick: handleCopy,
+            "aria-label": "Copy code",
+            children: copied ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(CheckIcon, {}) : /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(CopyIcon, {})
+          }
+        ),
+        exportable && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+          "button",
+          {
+            type: "button",
+            className: "code-block__btn",
+            onClick: handleExport,
+            "aria-label": "Download code",
+            children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(DownloadIcon, {})
+          }
+        ),
+        exportImage && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+          "button",
+          {
+            type: "button",
+            className: "code-block__btn",
+            onClick: handleExportImage,
+            "aria-label": "Export as image",
+            children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(ImageIcon, {})
+          }
+        ),
+        onConvertToMermaid && language !== "mermaid" && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+          "button",
+          {
+            type: "button",
+            className: "code-block__btn",
+            onClick: () => onConvertToMermaid(code),
+            title: "Convert to Mermaid diagram",
+            "aria-label": "Convert to Mermaid diagram",
+            children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(MermaidIcon, {})
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(
+      "div",
+      {
+        className: [
+          "code-block__body",
+          maxHeight ? "code-block__body--scrollable" : ""
+        ].filter(Boolean).join(" "),
+        style: bodyStyle,
+        children: [
+          showLineNumbers && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { className: "code-block__gutter", "aria-hidden": "true", children: lines.map((_, i) => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { className: "code-block__line-number", children: i + 1 }, i)) }),
+          /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("pre", { className: `code-block__code ${wrapped ? "code-block__code--wrapped" : ""}`, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("code", { children: lines.map((line, i) => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+            "div",
+            {
+              className: [
+                "code-block__line",
+                highlightSet.has(i + 1) ? "code-block__line--highlighted" : ""
+              ].filter(Boolean).join(" "),
+              children: language ? tokenizeLine(line, language).map(
+                (tok, j) => tok.className ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("span", { className: tok.className, children: tok.text }, j) : /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("span", { children: tok.text }, j)
+              ) : line || "\n"
+            },
+            i
+          )) }) })
+        ]
+      }
+    )
+  ] });
+};
+
+// src/GitDiffView/GitDiffView.tsx
+var import_jsx_runtime6 = require("react/jsx-runtime");
+function computeLCS(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from(
+    { length: m + 1 },
+    () => Array(n + 1).fill(0)
+  );
+  for (let i2 = 1; i2 <= m; i2++) {
+    for (let j2 = 1; j2 <= n; j2++) {
+      dp[i2][j2] = a[i2 - 1] === b[j2 - 1] ? dp[i2 - 1][j2 - 1] + 1 : Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
+    }
+  }
+  const result = [];
+  let i = m;
+  let j = n;
+  while (i > 0 && j > 0) {
+    if (a[i - 1] === b[j - 1]) {
+      result.unshift(a[i - 1]);
+      i--;
+      j--;
+    } else if (dp[i - 1][j] > dp[i][j - 1]) {
+      i--;
+    } else {
+      j--;
+    }
+  }
+  return result;
+}
+function computeDiff(original, modified) {
+  const oldLines = original.split("\n");
+  const newLines = modified.split("\n");
+  const lcs = computeLCS(oldLines, newLines);
+  const result = [];
+  let oldIdx = 0;
+  let newIdx = 0;
+  let lcsIdx = 0;
+  while (oldIdx < oldLines.length || newIdx < newLines.length) {
+    if (lcsIdx < lcs.length && oldIdx < oldLines.length && oldLines[oldIdx] === lcs[lcsIdx] && newIdx < newLines.length && newLines[newIdx] === lcs[lcsIdx]) {
+      result.push({
+        type: "unchanged",
+        content: lcs[lcsIdx],
+        oldLineNumber: oldIdx + 1,
+        newLineNumber: newIdx + 1
+      });
+      oldIdx++;
+      newIdx++;
+      lcsIdx++;
+    } else if (oldIdx < oldLines.length && (lcsIdx >= lcs.length || oldLines[oldIdx] !== lcs[lcsIdx])) {
+      result.push({
+        type: "removed",
+        content: oldLines[oldIdx],
+        oldLineNumber: oldIdx + 1
+      });
+      oldIdx++;
+    } else if (newIdx < newLines.length && (lcsIdx >= lcs.length || newLines[newIdx] !== lcs[lcsIdx])) {
+      result.push({
+        type: "added",
+        content: newLines[newIdx],
+        newLineNumber: newIdx + 1
+      });
+      newIdx++;
+    }
+  }
+  return result;
+}
+var GitDiffView = ({
+  original,
+  modified,
+  language,
+  fileName,
+  mode = "inline",
+  lineNumbers = true,
+  className
+}) => {
+  const diffLines = computeDiff(original, modified);
+  const added = diffLines.filter((l) => l.type === "added").length;
+  const removed = diffLines.filter((l) => l.type === "removed").length;
+  const cls = [
+    "git-diff",
+    mode === "side-by-side" ? "git-diff--sbs" : "git-diff--inline",
+    className
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("div", { className: cls, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("div", { className: "git-diff__header", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("div", { className: "git-diff__header-left", children: [
+        fileName && /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("span", { className: "git-diff__filename", children: fileName }),
+        language && /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("span", { className: "git-diff__badge", children: language })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("div", { className: "git-diff__stats", children: [
+        added > 0 && /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("span", { className: "git-diff__stat--added", children: [
+          "+",
+          added
+        ] }),
+        removed > 0 && /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("span", { className: "git-diff__stat--removed", children: [
+          "-",
+          removed
+        ] }),
+        added === 0 && removed === 0 && /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("span", { className: "git-diff__stat--none", children: "No changes" })
+      ] })
+    ] }),
+    mode === "side-by-side" ? /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(SideBySideView, { lines: diffLines, lineNumbers }) : /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(InlineView, { lines: diffLines, lineNumbers })
+  ] });
+};
+function InlineView({ lines, lineNumbers }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("div", { className: "git-diff__body", children: lines.map((line, i) => /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("div", { className: `git-diff__line git-diff__line--${line.type}`, children: [
+    lineNumbers && /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("span", { className: "git-diff__gutter git-diff__gutter--old", children: line.oldLineNumber ?? "" }),
+    lineNumbers && /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("span", { className: "git-diff__gutter git-diff__gutter--new", children: line.newLineNumber ?? "" }),
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("span", { className: "git-diff__prefix", children: line.type === "added" ? "+" : line.type === "removed" ? "-" : " " }),
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("span", { className: "git-diff__content", children: line.content || "\n" })
+  ] }, i)) });
+}
+function SideBySideView({ lines, lineNumbers }) {
+  const left = [];
+  const right = [];
+  let idx = 0;
+  while (idx < lines.length) {
+    const line = lines[idx];
+    if (line.type === "unchanged") {
+      left.push(line);
+      right.push(line);
+      idx++;
+    } else {
+      const removedBatch = [];
+      const addedBatch = [];
+      while (idx < lines.length && lines[idx].type === "removed") {
+        removedBatch.push(lines[idx]);
+        idx++;
+      }
+      while (idx < lines.length && lines[idx].type === "added") {
+        addedBatch.push(lines[idx]);
+        idx++;
+      }
+      const max = Math.max(removedBatch.length, addedBatch.length);
+      for (let j = 0; j < max; j++) {
+        left.push(j < removedBatch.length ? removedBatch[j] : null);
+        right.push(j < addedBatch.length ? addedBatch[j] : null);
+      }
+    }
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("div", { className: "git-diff__sbs-body", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("div", { className: "git-diff__side", children: left.map((line, i) => /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(
+      "div",
+      {
+        className: `git-diff__line ${line ? `git-diff__line--${line.type}` : "git-diff__line--empty"}`,
+        children: [
+          lineNumbers && /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("span", { className: "git-diff__gutter", children: line?.oldLineNumber ?? "" }),
+          /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("span", { className: "git-diff__content", children: line?.content || "\xA0" })
+        ]
+      },
+      i
+    )) }),
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("div", { className: "git-diff__side", children: right.map((line, i) => /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(
+      "div",
+      {
+        className: `git-diff__line ${line ? `git-diff__line--${line.type}` : "git-diff__line--empty"}`,
+        children: [
+          lineNumbers && /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("span", { className: "git-diff__gutter", children: line?.newLineNumber ?? "" }),
+          /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("span", { className: "git-diff__content", children: line?.content || "\xA0" })
+        ]
+      },
+      i
+    )) })
+  ] });
+}
+
+// src/MarkdownEditor/MarkdownEditor.tsx
+var import_react10 = require("react");
+
+// src/MarkdownRenderer/MarkdownRenderer.tsx
+var import_react9 = require("react");
+
+// src/DataTable/index.ts
+var import_widgets3 = require("@orchestra-mcp/widgets");
+
+// src/MarkdownRenderer/MarkdownRenderer.tsx
+var import_ui = require("@orchestra-mcp/ui");
+
+// src/MarkdownRenderer/parseMarkdown.ts
+var UL_RE = /^\s*[-*+]\s/;
+var OL_RE = /^\s*\d+[.)]\s/;
+var LIST_RE = (line) => UL_RE.test(line) || OL_RE.test(line);
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").trim();
+}
+function parseAlignments(separatorLine) {
+  return separatorLine.split("|").map((c) => c.trim()).filter(Boolean).map((cell) => {
+    const left = cell.startsWith(":");
+    const right = cell.endsWith(":");
+    if (left && right) return "center";
+    if (right) return "right";
+    return "left";
+  });
+}
+function parseTable(lines) {
+  if (lines.length < 2) return null;
+  const parse = (line) => line.split("|").map((c) => c.trim()).filter(Boolean);
+  const headers = parse(lines[0]);
+  if (!lines[1].match(/^\|?[\s-:|]+\|?$/)) return null;
+  const alignments = parseAlignments(lines[1]);
+  const rows = lines.slice(2).map(parse);
+  return { type: "table", headers, rows, alignments };
+}
+function parseListBlock(lines) {
+  const stripped = lines.map((l) => l.replace(/^\s+/, ""));
+  const taskMatch = stripped[0].match(/^[-*+]\s+\[([ xX])\]/);
+  if (taskMatch) {
+    const items = stripped.map((l) => {
+      const m = l.match(/^[-*+]\s+\[([ xX])\]\s*(.*)/);
+      return { checked: m ? m[1] !== " " : false, text: m ? m[2] : l };
+    });
+    return { type: "task-list", items };
+  }
+  if (OL_RE.test(stripped[0])) {
+    return { type: "ordered-list", items: stripped.map((l) => l.replace(/^\d+[.)]\s*/, "")) };
+  }
+  return { type: "unordered-list", items: stripped.map((l) => l.replace(/^[-*+]\s*/, "")) };
+}
+function parseYaml(lines) {
+  const data = {};
+  for (const line of lines) {
+    const match = line.match(/^(\w[\w\s-]*):\s*(.*)/);
+    if (match) {
+      const key = match[1].trim();
+      let value = match[2].trim();
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      data[key] = value;
+    }
+  }
+  return data;
+}
+function parseMarkdown(content) {
+  const blocks = [];
+  const rawLines = content.split("\n");
+  let i = 0;
+  if (rawLines[0]?.trim() === "---") {
+    i = 1;
+    const fmLines = [];
+    while (i < rawLines.length && rawLines[i].trim() !== "---") {
+      fmLines.push(rawLines[i]);
+      i++;
+    }
+    if (i < rawLines.length) {
+      i++;
+      const data = parseYaml(fmLines);
+      if (Object.keys(data).length > 0) {
+        blocks.push({ type: "frontmatter", data });
+      }
+    } else {
+      i = 0;
+    }
+  }
+  while (i < rawLines.length) {
+    const line = rawLines[i];
+    if (line.trim() === "") {
+      i++;
+      continue;
+    }
+    if (/^[-*_]{3,}$/.test(line.trim())) {
+      blocks.push({ type: "hr" });
+      i++;
+      continue;
+    }
+    const headingMatch = line.match(/^(#{1,6})\s+(.*)/);
+    if (headingMatch) {
+      const text = headingMatch[2];
+      blocks.push({ type: "heading", level: headingMatch[1].length, text, id: slugify(text) });
+      i++;
+      continue;
+    }
+    const codeMatch = line.match(/^```(\w*)/);
+    if (codeMatch) {
+      const language = codeMatch[1] || "";
+      const codeLines = [];
+      i++;
+      while (i < rawLines.length && !rawLines[i].startsWith("```")) {
+        codeLines.push(rawLines[i]);
+        i++;
+      }
+      blocks.push({ type: "code", language, code: codeLines.join("\n") });
+      i++;
+      continue;
+    }
+    if (line.includes("|") && i + 1 < rawLines.length && rawLines[i + 1].match(/^\|?[\s-:|]+\|?$/)) {
+      const tableLines = [];
+      while (i < rawLines.length && rawLines[i].includes("|")) {
+        tableLines.push(rawLines[i]);
+        i++;
+      }
+      const table = parseTable(tableLines);
+      if (table) {
+        blocks.push(table);
+        continue;
+      }
+    }
+    if (line.startsWith(">")) {
+      const quoteLines = [];
+      while (i < rawLines.length && rawLines[i].startsWith(">")) {
+        quoteLines.push(rawLines[i].replace(/^>\s?/, ""));
+        i++;
+      }
+      blocks.push({ type: "blockquote", text: quoteLines.join("\n") });
+      continue;
+    }
+    if (LIST_RE(line)) {
+      const listLines = [];
+      while (i < rawLines.length) {
+        const cur = rawLines[i];
+        if (cur.trim() === "") break;
+        if (LIST_RE(cur)) {
+          listLines.push(cur);
+          i++;
+        } else if (listLines.length > 0 && (cur.startsWith("  ") || cur.startsWith("	"))) {
+          listLines[listLines.length - 1] += " " + cur.trim();
+          i++;
+        } else {
+          break;
+        }
+      }
+      blocks.push(parseListBlock(listLines));
+      continue;
+    }
+    const paraLines = [];
+    while (i < rawLines.length && rawLines[i].trim() !== "" && !rawLines[i].match(/^(#{1,6}\s|```|>|---+$)/) && !LIST_RE(rawLines[i]) && !(rawLines[i].includes("|") && i + 1 < rawLines.length && rawLines[i + 1]?.match(/^\|?[\s-:|]+\|?$/))) {
+      paraLines.push(rawLines[i]);
+      i++;
+    }
+    if (paraLines.length > 0) {
+      blocks.push({ type: "paragraph", text: paraLines.join(" ") });
+    }
+  }
+  return blocks;
+}
+
+// src/MarkdownRenderer/inlineFormat.ts
+function formatInline(text) {
+  let result = text;
+  result = result.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  const codeSlots = [];
+  result = result.replace(/`([^`]+)`/g, (_, code) => {
+    const idx = codeSlots.length;
+    codeSlots.push(`<code class="markdown-renderer__inline-code">${code}</code>`);
+    return `\0CODE${idx}\0`;
+  });
+  result = result.replace(
+    /!\[([^\]]*)\]\(([^)]+)\)/g,
+    '<img src="$2" alt="$1" loading="lazy" class="markdown-renderer__img" />'
+  );
+  result = result.replace(
+    /\[([^\]]+)\]\(([^)]+)\)/g,
+    '<a role="link" class="markdown-renderer__link" data-md-link="$2" style="color:var(--color-link,var(--color-primary,var(--primary,#6366f1)));opacity:0.75;cursor:pointer;text-decoration:none">$1</a>'
+  );
+  result = result.replace(/\*\*\*(.+?)\*\*\*/g, "<strong><em>$1</em></strong>");
+  result = result.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>");
+  result = result.replace(/__(.+?)__/g, "<strong>$1</strong>");
+  result = result.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, "<em>$1</em>");
+  result = result.replace(/(?<!_)_(?!_)(.+?)(?<!_)_(?!_)/g, "<em>$1</em>");
+  result = result.replace(/~~(.+?)~~/g, "<del>$1</del>");
+  result = result.replace(/\x00CODE(\d+)\x00/g, (_, idx) => codeSlots[parseInt(idx)]);
+  return result;
+}
+
+// src/MarkdownRenderer/MarkdownRenderer.tsx
+var import_jsx_runtime7 = require("react/jsx-runtime");
+var MarkdownRenderer = ({
+  content,
+  className,
+  onLinkClick,
+  onConvertToMermaid
+}) => {
+  const blocks = (0, import_react9.useMemo)(() => parseMarkdown(content), [content]);
+  const handleClick = (0, import_react9.useCallback)(
+    (e) => {
+      const target = e.target;
+      const link = target.closest("[data-md-link]");
+      if (link && onLinkClick) {
+        e.preventDefault();
+        onLinkClick(link.dataset.mdLink);
+      }
+    },
+    [onLinkClick]
+  );
+  const wrapperClass = ["markdown-renderer", className].filter(Boolean).join(" ");
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("div", { className: wrapperClass, onClick: handleClick, children: blocks.map((block, i) => /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(BlockRenderer, { block, onLinkClick, onConvertToMermaid }, i)) });
+};
+function renderHeading(level, id, text) {
+  const anchor = /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("a", { href: `#${id}`, className: "markdown-renderer__heading-anchor", "aria-hidden": "true", children: "#" });
+  const inner = /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("span", { dangerouslySetInnerHTML: { __html: formatInline(text) } });
+  if (level === 1) return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("h1", { id, children: [
+    anchor,
+    inner
+  ] });
+  if (level === 2) return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("h2", { id, children: [
+    anchor,
+    inner
+  ] });
+  if (level === 3) return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("h3", { id, children: [
+    anchor,
+    inner
+  ] });
+  if (level === 4) return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("h4", { id, children: [
+    anchor,
+    inner
+  ] });
+  if (level === 5) return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("h5", { id, children: [
+    anchor,
+    inner
+  ] });
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("h6", { id, children: [
+    anchor,
+    inner
+  ] });
+}
+function BlockRenderer({ block, onLinkClick, onConvertToMermaid }) {
+  switch (block.type) {
+    case "heading":
+      return renderHeading(block.level, block.id, block.text);
+    case "paragraph":
+      return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("p", { dangerouslySetInnerHTML: { __html: formatInline(block.text) } });
+    case "code":
+      return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(CodeBlock, { code: block.code, language: block.language || void 0, copyable: true, exportable: true, exportImage: true, onConvertToMermaid });
+    case "frontmatter":
+      return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("div", { className: "markdown-renderer__frontmatter", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("div", { className: "markdown-renderer__frontmatter-header", children: "Metadata" }),
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("table", { className: "markdown-renderer__frontmatter-table", children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("tbody", { children: Object.entries(block.data).map(([key, value]) => /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("tr", { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("td", { className: "markdown-renderer__frontmatter-key", children: key }),
+          /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("td", { className: "markdown-renderer__frontmatter-value", children: String(value) })
+        ] }, key)) }) })
+      ] });
+    case "table": {
+      const columns = block.headers.map((h, i) => ({
+        key: `col-${i}`,
+        header: h,
+        align: block.alignments[i] ?? "left"
+      }));
+      return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_widgets3.DataTable, { columns, rows: block.rows, showHeader: true, exportable: true, exportImage: true, renderCell: formatInline, onLinkClick });
+    }
+    case "blockquote":
+      return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("blockquote", { dangerouslySetInnerHTML: { __html: formatInline(block.text) } });
+    case "unordered-list":
+      return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("ul", { children: block.items.map((item, i) => /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("li", { dangerouslySetInnerHTML: { __html: formatInline(item) } }, i)) });
+    case "ordered-list":
+      return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("ol", { children: block.items.map((item, i) => /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("li", { dangerouslySetInnerHTML: { __html: formatInline(item) } }, i)) });
+    case "task-list":
+      return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("ul", { className: "task-list", children: block.items.map((item, i) => /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("li", { className: "task-list__item", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+          import_ui.Checkbox,
+          {
+            checked: item.checked,
+            color: item.checked ? "success" : void 0,
+            className: "task-list__checkbox"
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("span", { dangerouslySetInnerHTML: { __html: formatInline(item.text) } })
+      ] }, i)) });
+    case "hr":
+      return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("hr", {});
+  }
+}
+
+// src/MarkdownEditor/MarkdownEditor.tsx
+var import_jsx_runtime8 = require("react/jsx-runtime");
+var MarkdownEditor = ({
+  value,
+  onChange,
+  placeholder,
+  readOnly = false,
+  hidePreview = false,
+  className
+}) => {
+  const textareaRef = (0, import_react10.useRef)(null);
+  const wrapSelection = (0, import_react10.useCallback)(
+    (before, after) => {
+      const ta = textareaRef.current;
+      if (!ta) return;
+      const start = ta.selectionStart;
+      const end = ta.selectionEnd;
+      const selected = value.slice(start, end);
+      const newValue = value.slice(0, start) + before + selected + after + value.slice(end);
+      onChange(newValue);
+      requestAnimationFrame(() => {
+        ta.focus();
+        ta.selectionStart = start + before.length;
+        ta.selectionEnd = end + before.length;
+      });
+    },
+    [value, onChange]
+  );
+  const insertLinePrefix = (0, import_react10.useCallback)(
+    (prefix) => {
+      const ta = textareaRef.current;
+      if (!ta) return;
+      const pos = ta.selectionStart;
+      const lineStart = value.lastIndexOf("\n", pos - 1) + 1;
+      const newValue = value.slice(0, lineStart) + prefix + value.slice(lineStart);
+      onChange(newValue);
+      requestAnimationFrame(() => {
+        ta.focus();
+        ta.selectionStart = pos + prefix.length;
+        ta.selectionEnd = pos + prefix.length;
+      });
+    },
+    [value, onChange]
+  );
+  const handleBold = (0, import_react10.useCallback)(() => wrapSelection("**", "**"), [wrapSelection]);
+  const handleItalic = (0, import_react10.useCallback)(() => wrapSelection("*", "*"), [wrapSelection]);
+  const handleLink = (0, import_react10.useCallback)(() => wrapSelection("[", "](url)"), [wrapSelection]);
+  const handleHeading = (0, import_react10.useCallback)(() => insertLinePrefix("## "), [insertLinePrefix]);
+  const handleUl = (0, import_react10.useCallback)(() => insertLinePrefix("- "), [insertLinePrefix]);
+  const handleOl = (0, import_react10.useCallback)(() => insertLinePrefix("1. "), [insertLinePrefix]);
+  const handleCode = (0, import_react10.useCallback)(() => {
+    const ta = textareaRef.current;
+    if (!ta) return;
+    const selected = value.slice(ta.selectionStart, ta.selectionEnd);
+    if (selected.includes("\n")) {
+      wrapSelection("```\n", "\n```");
+    } else {
+      wrapSelection("`", "`");
+    }
+  }, [value, wrapSelection]);
+  const toolbarActions = (0, import_react10.useMemo)(
+    () => [
+      { label: "B", title: "Bold (Ctrl+B)", action: handleBold },
+      { label: "I", title: "Italic (Ctrl+I)", action: handleItalic },
+      { label: "H", title: "Heading", action: handleHeading },
+      { label: "UL", title: "Unordered list", action: handleUl },
+      { label: "OL", title: "Ordered list", action: handleOl },
+      { label: "<>", title: "Code", action: handleCode },
+      { label: "Link", title: "Link (Ctrl+K)", action: handleLink }
+    ],
+    [handleBold, handleItalic, handleHeading, handleUl, handleOl, handleCode, handleLink]
+  );
+  const handleKeyDown = (0, import_react10.useCallback)(
+    (e) => {
+      const mod = e.metaKey || e.ctrlKey;
+      if (!mod) return;
+      if (e.key === "b") {
+        e.preventDefault();
+        handleBold();
+      } else if (e.key === "i") {
+        e.preventDefault();
+        handleItalic();
+      } else if (e.key === "k") {
+        e.preventDefault();
+        handleLink();
+      }
+    },
+    [handleBold, handleItalic, handleLink]
+  );
+  const wordCount = (0, import_react10.useMemo)(() => {
+    return value.trim().split(/\s+/).filter(Boolean).length;
+  }, [value]);
+  const readingTime = (0, import_react10.useMemo)(() => {
+    return Math.max(1, Math.ceil(wordCount / 200));
+  }, [wordCount]);
+  const wrapperClass = ["md-editor", className].filter(Boolean).join(" ");
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { className: wrapperClass, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { className: "md-editor__toolbar", role: "toolbar", "aria-label": "Formatting", children: toolbarActions.map((btn) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+      "button",
+      {
+        type: "button",
+        className: "md-editor__toolbar-btn",
+        title: btn.title,
+        disabled: readOnly,
+        onClick: btn.action,
+        children: btn.label
+      },
+      btn.label
+    )) }),
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { className: "md-editor__body", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { className: "md-editor__source", children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+        "textarea",
+        {
+          ref: textareaRef,
+          value,
+          onChange: (e) => onChange(e.target.value),
+          onKeyDown: handleKeyDown,
+          placeholder,
+          readOnly,
+          "aria-label": "Markdown source"
+        }
+      ) }),
+      !hidePreview && /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_jsx_runtime8.Fragment, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { className: "md-editor__divider" }),
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { className: "md-editor__preview", children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(MarkdownRenderer, { content: value }) })
+      ] })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { className: "md-editor__footer", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("span", { "data-testid": "word-count", children: [
+        wordCount,
+        " words"
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("span", { "data-testid": "reading-time", children: [
+        readingTime,
+        " min read"
+      ] })
+    ] })
+  ] });
+};
+
+// src/index.ts
+init_exportToImage();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CodeBlock,
+  CodeDiffEditor,
+  CodeEditor,
+  GitDiffView,
+  LegacyCodeEditor,
+  MarkdownEditor,
+  MarkdownRenderer,
+  computeDiff,
+  exportToImage,
+  getMonacoThemeId,
+  languageFromFilename,
+  orchestraToMonacoTheme,
+  resolveLanguage
+});