@sendbird/actionbook-core 0.7.2 → 0.8.1

package/dist/ui/index.js

@@ -32,9 +32,12 @@ var actionbookSchema = new Schema({
     bulletList: {
       content: "listItem+",
       group: "block",
-      parseDOM: [{ tag: "ul" }],
+      parseDOM: [
+        { tag: "div.ab-bullet-list" },
+        { tag: "ul" }
+      ],
       toDOM() {
-        return ["ul", 0];
+        return ["div", { class: "ab-bullet-list", role: "list" }, 0];
       }
     },
     orderedList: {
@@ -42,6 +45,12 @@ var actionbookSchema = new Schema({
       group: "block",
       attrs: { start: { default: 1 } },
       parseDOM: [
+        {
+          tag: "div.ab-ordered-list",
+          getAttrs(dom) {
+            return { start: Number(dom.dataset.start) || 1 };
+          }
+        },
         {
           tag: "ol",
           getAttrs(dom) {
@@ -50,13 +59,25 @@ var actionbookSchema = new Schema({
         }
       ],
       toDOM(node) {
-        return node.attrs.start === 1 ? ["ol", 0] : ["ol", { start: node.attrs.start }, 0];
+        const attrs = { class: "ab-ordered-list", role: "list" };
+        if (node.attrs.start !== 1) attrs["data-start"] = String(node.attrs.start);
+        return ["div", attrs, 0];
       }
     },
     listItem: {
       content: "block+",
       attrs: { checked: { default: null } },
       parseDOM: [
+        {
+          tag: "div.ab-list-item",
+          getAttrs(dom) {
+            const el = dom;
+            if (el.dataset.checked != null) {
+              return { checked: el.dataset.checked === "true" };
+            }
+            return { checked: null };
+          }
+        },
         {
           tag: "li",
           getAttrs(dom) {
@@ -73,10 +94,12 @@ var actionbookSchema = new Schema({
         }
       ],
       toDOM(node) {
+        const attrs = { class: "ab-list-item", role: "listitem" };
         if (node.attrs.checked != null) {
-          return ["li", { class: "todo-item", "data-checked": String(node.attrs.checked) }, 0];
+          attrs.class = "ab-list-item todo-item";
+          attrs["data-checked"] = String(node.attrs.checked);
         }
-        return ["li", 0];
+        return ["div", attrs, 0];
       },
       defining: true
     },
@@ -89,6 +112,72 @@ var actionbookSchema = new Schema({
       },
       defining: true
     },
+    codeBlock: {
+      content: "text*",
+      group: "block",
+      code: true,
+      defining: true,
+      marks: "",
+      attrs: { language: { default: null } },
+      parseDOM: [
+        {
+          tag: "pre",
+          preserveWhitespace: "full",
+          getAttrs(dom) {
+            const code3 = dom.querySelector("code");
+            return { language: code3?.getAttribute("data-language") || null };
+          }
+        }
+      ],
+      toDOM(node) {
+        const attrs = {};
+        if (node.attrs.language) attrs["data-language"] = node.attrs.language;
+        return ["pre", ["code", attrs, 0]];
+      }
+    },
+    jinjaIfBlock: {
+      content: "jinjaIfBranch+",
+      group: "block",
+      isolating: true,
+      defining: true,
+      parseDOM: [{ tag: "div[data-jinja-if-block]" }],
+      toDOM() {
+        return ["div", { "data-jinja-if-block": "", class: "jinja-if-block" }, 0];
+      }
+    },
+    jinjaIfBranch: {
+      content: "block+",
+      isolating: true,
+      defining: true,
+      attrs: {
+        branchType: { default: "if" },
+        condition: { default: "" }
+      },
+      parseDOM: [
+        {
+          tag: "div[data-jinja-branch]",
+          getAttrs(dom) {
+            const el = dom;
+            return {
+              branchType: el.getAttribute("data-branch-type") || "if",
+              condition: el.getAttribute("data-condition") || ""
+            };
+          }
+        }
+      ],
+      toDOM(node) {
+        return [
+          "div",
+          {
+            "data-jinja-branch": "",
+            "data-branch-type": node.attrs.branchType,
+            "data-condition": node.attrs.condition,
+            class: `jinja-branch jinja-branch-${node.attrs.branchType}`
+          },
+          0
+        ];
+      }
+    },
     horizontalRule: {
       group: "block",
       parseDOM: [{ tag: "hr" }],
@@ -1996,8 +2085,7 @@ function convertInline2(node) {
       return assertNever(node);
   }
 }
-var MAX_LIST_DEPTH = 3;
-function convertBlockToArray(node, listDepth = 0) {
+function convertBlockToArray(node) {
   if (node.type === "jinjaIfBlock") {
     const jNode = node;
     const result = [];
@@ -2005,15 +2093,15 @@ function convertBlockToArray(node, listDepth = 0) {
       const tagText = branch.branchType === "else" ? "{% else %}" : `{% ${branch.branchType} ${branch.condition ?? ""} %}`.trim();
       result.push({ type: "paragraph", content: [{ type: "text", text: tagText }] });
       for (const child of branch.content) {
-        result.push(...convertBlockToArray(child, listDepth));
+        result.push(...convertBlockToArray(child));
       }
     }
     result.push({ type: "paragraph", content: [{ type: "text", text: "{% endif %}" }] });
     return result;
   }
-  return [convertBlock2(node, listDepth)];
+  return [convertBlock2(node)];
 }
-function convertBlock2(node, listDepth = 0) {
+function convertBlock2(node) {
   switch (node.type) {
     case "paragraph":
       return {
@@ -2026,29 +2114,21 @@ function convertBlock2(node, listDepth = 0) {
         attrs: { level: node.level },
         content: node.content.flatMap(convertInlineToArray)
       };
-    case "bulletList": {
-      if (listDepth >= MAX_LIST_DEPTH) {
-        return flattenListToBlock(node);
-      }
+    case "bulletList":
       return {
         type: "bulletList",
-        content: node.content.map((c) => convertBlock2(c, listDepth + 1))
+        content: node.content.map(convertBlock2)
       };
-    }
-    case "orderedList": {
-      if (listDepth >= MAX_LIST_DEPTH) {
-        return flattenListToBlock(node);
-      }
+    case "orderedList":
       return {
         type: "orderedList",
         attrs: { start: node.start },
-        content: node.content.map((c) => convertBlock2(c, listDepth + 1))
+        content: node.content.map(convertBlock2)
       };
-    }
     case "listItem": {
       const result = {
         type: "listItem",
-        content: node.content.flatMap((c) => convertBlockToArray(c, listDepth))
+        content: node.content.flatMap(convertBlockToArray)
       };
       if (node.checked != null) {
         result.attrs = { checked: node.checked };
@@ -2058,7 +2138,7 @@ function convertBlock2(node, listDepth = 0) {
     case "blockquote":
       return {
         type: "blockquote",
-        content: node.content.flatMap((c) => convertBlockToArray(c, listDepth))
+        content: node.content.flatMap(convertBlockToArray)
       };
     case "horizontalRule":
       return { type: "horizontalRule" };
@@ -2080,7 +2160,7 @@ function convertBlock2(node, listDepth = 0) {
         const tagText = branch.branchType === "else" ? "{% else %}" : `{% ${branch.branchType} ${branch.condition ?? ""} %}`.trim();
         result.push({ type: "paragraph", content: [{ type: "text", text: tagText }] });
         for (const child of branch.content) {
-          result.push(...convertBlockToArray(child, listDepth));
+          result.push(...convertBlockToArray(child));
         }
       }
       result.push({ type: "paragraph", content: [{ type: "text", text: "{% endif %}" }] });
@@ -2090,36 +2170,10 @@ function convertBlock2(node, listDepth = 0) {
       return assertNever(node);
   }
 }
-function flattenListToBlock(node) {
-  const paragraphs = [];
-  function extractInlines(n) {
-    switch (n.type) {
-      case "paragraph":
-      case "heading":
-        paragraphs.push({
-          type: "paragraph",
-          content: n.content.flatMap(convertInlineToArray)
-        });
-        break;
-      case "listItem":
-      case "blockquote":
-        for (const child of n.content) extractInlines(child);
-        break;
-      case "bulletList":
-      case "orderedList":
-        for (const item of n.content) extractInlines(item);
-        break;
-      default:
-        break;
-    }
-  }
-  extractInlines(node);
-  return paragraphs.length > 0 ? paragraphs[0] : { type: "paragraph", content: [] };
-}
 function toProseMirrorJSON(doc2) {
   return {
     type: "doc",
-    content: doc2.content.flatMap((c) => convertBlockToArray(c, 0))
+    content: doc2.content.flatMap(convertBlockToArray)
   };
 }
 function astNodesToJSONContent(nodes) {
@@ -2210,6 +2264,15 @@ function useEditorView(config) {
   };
 }
 
+// src/ui/plugin/historyPlugin.ts
+import { history } from "prosemirror-history";
+function createHistoryPlugin() {
+  return {
+    name: "history",
+    plugins: () => [history()]
+  };
+}
+
 // src/ui/plugin/inputRulesPlugin.ts
 import { InputRule, wrappingInputRule } from "prosemirror-inputrules";
 var BULLET_LIST_RE = /^\s*([-*])\s$/;
@@ -4322,6 +4385,113 @@ function createJumpPointNodeViewPlugin() {
   };
 }
 
+// src/ui/plugin/jumpPointValidationPlugin.ts
+import { Plugin as Plugin3, PluginKey as PluginKey3 } from "prosemirror-state";
+import { Decoration as Decoration2, DecorationSet as DecorationSet2 } from "prosemirror-view";
+var validationKey = new PluginKey3("jumpPointValidation");
+function buildValidationDecorations(doc2) {
+  const jumpPointIds = /* @__PURE__ */ new Map();
+  const anchorRefs = [];
+  doc2.descendants((node, pos) => {
+    if (node.type.name === "jumpPoint") {
+      const id = node.attrs.id;
+      if (!jumpPointIds.has(id)) jumpPointIds.set(id, []);
+      jumpPointIds.get(id).push(pos);
+    }
+    if (node.isText && node.marks) {
+      for (const mark of node.marks) {
+        if (mark.type.name === "link") {
+          const href = mark.attrs.href;
+          if (href?.startsWith("#")) {
+            anchorRefs.push({ from: pos, to: pos + node.nodeSize, id: href.slice(1) });
+          }
+        }
+      }
+    }
+  });
+  const decorations = [];
+  for (const [, positions] of jumpPointIds) {
+    if (positions.length > 1) {
+      for (const pos of positions) {
+        decorations.push(
+          Decoration2.node(pos, pos + 1, { class: "duplicate-jump-point" })
+        );
+      }
+    }
+  }
+  for (const ref of anchorRefs) {
+    if (!jumpPointIds.has(ref.id)) {
+      decorations.push(
+        Decoration2.inline(ref.from, ref.to, { class: "broken-anchor-ref" })
+      );
+    }
+  }
+  return decorations.length > 0 ? DecorationSet2.create(doc2, decorations) : DecorationSet2.empty;
+}
+function createJumpPointValidationPlugin() {
+  return {
+    name: "jumpPointValidation",
+    plugins: () => [
+      new Plugin3({
+        key: validationKey,
+        state: {
+          init(_, state) {
+            return buildValidationDecorations(state.doc);
+          },
+          apply(tr, oldDecos) {
+            if (!tr.docChanged) return oldDecos;
+            return buildValidationDecorations(tr.doc);
+          }
+        },
+        props: {
+          decorations(state) {
+            return validationKey.getState(state);
+          }
+        }
+      })
+    ]
+  };
+}
+function hasDuplicateJumpPoints(state) {
+  const ids = /* @__PURE__ */ new Set();
+  let hasDup = false;
+  state.doc.descendants((node) => {
+    if (node.type.name === "jumpPoint") {
+      const id = node.attrs.id;
+      if (ids.has(id)) {
+        hasDup = true;
+        return false;
+      }
+      ids.add(id);
+    }
+  });
+  return hasDup;
+}
+function hasBrokenAnchorRefs(state) {
+  const jumpPointIds = /* @__PURE__ */ new Set();
+  state.doc.descendants((node) => {
+    if (node.type.name === "jumpPoint") {
+      jumpPointIds.add(node.attrs.id);
+    }
+  });
+  let hasBroken = false;
+  state.doc.descendants((node) => {
+    if (hasBroken) return false;
+    if (node.isText && node.marks) {
+      for (const mark of node.marks) {
+        if (mark.type.name === "link") {
+          const href = mark.attrs.href;
+          if (href?.startsWith("#") && !jumpPointIds.has(href.slice(1))) {
+            hasBroken = true;
+            return false;
+          }
+        }
+      }
+    }
+  });
+  return hasBroken;
+}
+
 // src/ui/plugin/inlineToolTagNodeViewPlugin.tsx
 import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
 var RESOURCE_TAG_COLORS2 = {
@@ -4386,9 +4556,9 @@ function createInlineToolTagNodeViewPlugin() {
 }
 
 // src/ui/plugin/jinjaDecoration.ts
-import { Plugin as Plugin3, PluginKey as PluginKey3 } from "prosemirror-state";
-import { Decoration as Decoration2, DecorationSet as DecorationSet2 } from "prosemirror-view";
-var jinjaPluginKey = new PluginKey3("jinjaDecoration");
+import { Plugin as Plugin4, PluginKey as PluginKey4 } from "prosemirror-state";
+import { Decoration as Decoration3, DecorationSet as DecorationSet3 } from "prosemirror-view";
+var jinjaPluginKey = new PluginKey4("jinjaDecoration");
 var JINJA_TAG_RE = /\{%\s*(if|elif|else|endif)\s*([^%]*?)\s*%\}/g;
 function getBlockPositions(doc2) {
   const blocks = [];
@@ -4410,7 +4580,7 @@ function addInlineChipDecorations(doc2, decorations) {
       const to = from + match[0].length;
       const keyword = match[1];
       decorations.push(
-        Decoration2.inline(from, to, {
+        Decoration3.inline(from, to, {
           class: `jinja-chip jinja-chip-${keyword}`
         })
       );
@@ -4451,7 +4621,7 @@ function addStructureBorderDecorations(doc2, blocks, decorations) {
       const classes = ["jinja-bar", `jinja-bar-${branchType}`];
       if (i === first || prevType !== branchType) classes.push("jinja-bar-first");
       if (i === last || nextType !== branchType) classes.push("jinja-bar-last");
-      decorations.push(Decoration2.node(block.from, block.to, { class: classes.join(" ") }));
+      decorations.push(Decoration3.node(block.from, block.to, { class: classes.join(" ") }));
     }
   }
 }
@@ -4460,14 +4630,14 @@ function buildDecorations2(doc2) {
   const decorations = [];
   addInlineChipDecorations(doc2, decorations);
   addStructureBorderDecorations(doc2, blocks, decorations);
-  if (decorations.length === 0) return DecorationSet2.empty;
-  return DecorationSet2.create(doc2, decorations);
+  if (decorations.length === 0) return DecorationSet3.empty;
+  return DecorationSet3.create(doc2, decorations);
 }
 function createJinjaDecorationPlugin() {
   return {
     name: "jinjaDecoration",
     plugins: () => [
-      new Plugin3({
+      new Plugin4({
         key: jinjaPluginKey,
         state: {
           init(_, state) {
@@ -4488,12 +4658,1051 @@ function createJinjaDecorationPlugin() {
   };
 }
 
+// src/ui/plugin/jinjaIfBlockPlugin.tsx
+import { useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
+import { createRoot as createRoot2 } from "react-dom/client";
+
+// src/jinja/conditionHighlighter.ts
+var KEYWORDS = {
+  and: "AND",
+  or: "OR",
+  not: "NOT",
+  in: "IN",
+  is: "IS",
+  True: "BOOL",
+  False: "BOOL",
+  true: "BOOL",
+  false: "BOOL",
+  None: "NONE",
+  null: "NONE"
+};
+var CATEGORY_BY_TYPE = {
+  STRING: "value",
+  NUMBER: "value",
+  BOOL: "value",
+  NONE: "value",
+  IDENT: "variable",
+  AND: "operator",
+  OR: "operator",
+  NOT: "operator",
+  IN: "operator",
+  IS: "operator",
+  EQ: "operator",
+  NEQ: "operator",
+  LT: "operator",
+  GT: "operator",
+  LTE: "operator",
+  GTE: "operator",
+  LPAREN: "punctuation",
+  RPAREN: "punctuation"
+};
+var NEGATIVE_NUMBER_PRECEDERS = /* @__PURE__ */ new Set([
+  "AND",
+  "OR",
+  "NOT",
+  "IN",
+  "IS",
+  "EQ",
+  "NEQ",
+  "LT",
+  "GT",
+  "LTE",
+  "GTE",
+  "LPAREN"
+]);
+function canStartNegativeNumber(tokens) {
+  if (tokens.length === 0) {
+    return true;
+  }
+  const previous = tokens[tokens.length - 1];
+  return NEGATIVE_NUMBER_PRECEDERS.has(previous.type);
+}
+function finalizeTokens(input, rawTokens) {
+  const highlighted = [];
+  for (let i = 0; i < rawTokens.length; i++) {
+    const token = rawTokens[i];
+    const next = rawTokens[i + 1];
+    if (token.type === "IS" && next?.type === "NOT") {
+      highlighted.push({
+        text: input.slice(token.start, next.end),
+        start: token.start,
+        end: next.end,
+        category: "operator"
+      });
+      i++;
+      continue;
+    }
+    highlighted.push({
+      text: token.text,
+      start: token.start,
+      end: token.end,
+      category: CATEGORY_BY_TYPE[token.type]
+    });
+  }
+  return highlighted;
+}
+function tokenizeCondition(input) {
+  const rawTokens = [];
+  let i = 0;
+  while (i < input.length) {
+    const char = input[i];
+    if (/\s/.test(char)) {
+      i++;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      const start = i;
+      const quote = char;
+      i++;
+      while (i < input.length) {
+        if (input[i] === "\\" && i + 1 < input.length) {
+          i += 2;
+          continue;
+        }
+        if (input[i] === quote) {
+          i++;
+          rawTokens.push({
+            type: "STRING",
+            text: input.slice(start, i),
+            start,
+            end: i
+          });
+          break;
+        }
+        i++;
+      }
+      if (rawTokens[rawTokens.length - 1]?.start !== start) {
+        return finalizeTokens(input, rawTokens);
+      }
+      continue;
+    }
+    if (/[0-9]/.test(char) || char === "-" && i + 1 < input.length && /[0-9]/.test(input[i + 1]) && canStartNegativeNumber(rawTokens)) {
+      const start = i;
+      if (input[i] === "-") {
+        i++;
+      }
+      while (i < input.length && /[0-9]/.test(input[i])) {
+        i++;
+      }
+      if (i < input.length && input[i] === ".") {
+        i++;
+        while (i < input.length && /[0-9]/.test(input[i])) {
+          i++;
+        }
+      }
+      rawTokens.push({
+        type: "NUMBER",
+        text: input.slice(start, i),
+        start,
+        end: i
+      });
+      continue;
+    }
+    if (/[a-zA-Z_]/.test(char)) {
+      const start = i;
+      i++;
+      while (i < input.length && /[a-zA-Z0-9_.]/.test(input[i])) {
+        i++;
+      }
+      const text2 = input.slice(start, i);
+      rawTokens.push({
+        type: KEYWORDS[text2] ?? "IDENT",
+        text: text2,
+        start,
+        end: i
+      });
+      continue;
+    }
+    if (i + 1 < input.length) {
+      const twoChar = input.slice(i, i + 2);
+      if (twoChar === "==") {
+        rawTokens.push({ type: "EQ", text: twoChar, start: i, end: i + 2 });
+        i += 2;
+        continue;
+      }
+      if (twoChar === "!=") {
+        rawTokens.push({ type: "NEQ", text: twoChar, start: i, end: i + 2 });
+        i += 2;
+        continue;
+      }
+      if (twoChar === "<=") {
+        rawTokens.push({ type: "LTE", text: twoChar, start: i, end: i + 2 });
+        i += 2;
+        continue;
+      }
+      if (twoChar === ">=") {
+        rawTokens.push({ type: "GTE", text: twoChar, start: i, end: i + 2 });
+        i += 2;
+        continue;
+      }
+    }
+    if (char === "<") {
+      rawTokens.push({ type: "LT", text: char, start: i, end: i + 1 });
+      i++;
+      continue;
+    }
+    if (char === ">") {
+      rawTokens.push({ type: "GT", text: char, start: i, end: i + 1 });
+      i++;
+      continue;
+    }
+    if (char === "(") {
+      rawTokens.push({ type: "LPAREN", text: char, start: i, end: i + 1 });
+      i++;
+      continue;
+    }
+    if (char === ")") {
+      rawTokens.push({ type: "RPAREN", text: char, start: i, end: i + 1 });
+      i++;
+      continue;
+    }
+    return finalizeTokens(input, rawTokens);
+  }
+  return finalizeTokens(input, rawTokens);
+}
+
+// src/ui/plugin/jinjaIfBlockPlugin.tsx
+import { Fragment as Fragment2, jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+var PLACEHOLDER_TEXT = "Describe what AI agent should do when this condition is met";
+var CONDITION_PLACEHOLDER = "Write a condition in natural language";
+var STYLE_ID = "ab-jinja-if-block-styles";
+var JINJA_STYLES = `
+.jinja-if-block {
+  margin: 8px 0;
+}
+
+.jinja-branch {
+  position: relative;
+  display: grid;
+  grid-template-areas:
+    "header"
+    "body"
+    "footer";
+  gap: 0;
+}
+
+.jinja-branch-controls {
+  display: contents;
+}
+
+.jinja-branch-header {
+  grid-area: header;
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  padding: 8px;
+  border: 1px solid #E0E0E0;
+  border-radius: 4px;
+  background: #FFFFFF;
+}
+
+.jinja-branch-badge {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  height: 32px;
+  padding: 0 8px;
+  border-radius: 4px;
+  font-family: "Roboto Mono", monospace;
+  font-size: 13px;
+  font-weight: 700;
+  line-height: 20px;
+  letter-spacing: -0.3px;
+  white-space: nowrap;
+  flex-shrink: 0;
+}
+
+.jinja-branch-badge-if,
+.jinja-branch-badge-elif {
+  background: #E7F1FF;
+  color: #0D0D0D;
+}
+
+.jinja-branch-badge-else {
+  background: #F7F7F7;
+  color: #424242;
+}
+
+.jinja-branch-condition {
+  flex: 1;
+  min-width: 0;
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  align-items: center;
+  width: 100%;
+  padding: 0;
+  margin: 0;
+  background: transparent;
+  border: none;
+  color: #0D0D0D;
+  cursor: text;
+  text-align: left;
+  font-family: "Roboto Mono", monospace;
+  font-size: 13px;
+  line-height: 20px;
+  letter-spacing: -0.3px;
+  white-space: nowrap;
+}
+
+.jinja-branch-condition:focus-visible,
+.jinja-ghost-btn:focus-visible,
+.jinja-popup-item:focus-visible {
+  outline: 2px solid rgba(98, 16, 204, 0.28);
+  outline-offset: 2px;
+}
+
+.jinja-condition-placeholder {
+  color: #A6A6A6;
+  font-family: "Roboto Mono", monospace;
+  font-size: 13px;
+  line-height: 20px;
+  letter-spacing: -0.3px;
+}
+
+.jinja-token-variable {
+  color: #4141B2;
+}
+
+.jinja-token-operator {
+  color: #858585;
+}
+
+.jinja-token-value {
+  color: #0D0D0D;
+}
+
+.jinja-token-punctuation {
+  color: #858585;
+}
+
+.jinja-otherwise {
+  flex: 1;
+  color: #858585;
+  font-family: "Roboto Mono", monospace;
+  font-size: 13px;
+  line-height: 20px;
+  letter-spacing: -0.3px;
+}
+
+.jinja-branch-actions,
+.jinja-add-footer-actions {
+  position: relative;
+  display: inline-flex;
+  align-items: center;
+}
+
+.jinja-branch-body {
+  grid-area: body;
+  display: flex;
+  gap: 12px;
+  padding: 0 8px;
+  min-height: 52px;
+}
+
+.jinja-branch-divider-col {
+  width: 32px;
+  flex-shrink: 0;
+  display: flex;
+  align-items: stretch;
+  justify-content: center;
+}
+
+.jinja-branch-divider {
+  width: 1px;
+  background: #E0E0E0;
+}
+
+/* L-shaped divider for the last branch (ELSE) */
+.jinja-branch-last .jinja-branch-divider-col {
+  align-items: flex-start;
+  padding-left: 16px;
+}
+
+.jinja-branch-last .jinja-branch-divider {
+  width: 16px;
+  height: 28px;
+  background: none;
+  border-left: 1px solid #E0E0E0;
+  border-bottom: 1px solid #E0E0E0;
+  border-bottom-left-radius: 8px;
+}
+
+.jinja-branch-content {
+  position: relative;
+  flex: 1;
+  min-width: 0;
+  padding: 16px 0;
+}
+
+.jinja-branch-content.jinja-branch-content-empty::before {
+  content: attr(data-placeholder);
+  position: absolute;
+  top: 16px;
+  left: 0;
+  color: #A6A6A6;
+  font-size: 14px;
+  line-height: 20px;
+  pointer-events: none;
+}
+
+.jinja-add-footer {
+  grid-area: footer;
+  display: flex;
+  padding: 8px;
+}
+
+.jinja-add-footer .jinja-add-footer-col {
+  width: 32px;
+  flex-shrink: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.jinja-ghost-btn {
+  width: 24px;
+  height: 24px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  padding: 0;
+  border: none;
+  border-radius: 4px;
+  background: transparent;
+  color: #858585;
+  cursor: pointer;
+}
+
+.jinja-ghost-btn:hover:not(:disabled) {
+  background: rgba(13, 13, 13, 0.04);
+}
+
+.jinja-ghost-btn:disabled {
+  opacity: 0.45;
+  cursor: default;
+}
+
+.jinja-popup-menu {
+  position: absolute;
+  z-index: 20;
+  min-width: 200px;
+  padding: 8px 0;
+  background: #FFFFFF;
+  border-radius: 4px;
+  box-shadow: 0px 8px 10px 0px rgba(13,13,13,0.12), 0px 3px 14px 0px rgba(13,13,13,0.08), 0px 3px 5px 0px rgba(13,13,13,0.04);
+}
+
+.jinja-popup-item {
+  width: 100%;
+  display: block;
+  padding: 6px 16px;
+  border: none;
+  background: transparent;
+  color: #0D0D0D;
+  text-align: left;
+  cursor: pointer;
+  font-size: 14px;
+  line-height: 20px;
+  letter-spacing: -0.1px;
+}
+
+.jinja-popup-item:hover:not(:disabled) {
+  background: rgba(13, 13, 13, 0.04);
+}
+
+.jinja-popup-item:disabled {
+  color: #A6A6A6;
+  cursor: default;
+}
+
+.jinja-condition-input {
+  width: 100%;
+  min-width: 0;
+  padding: 0;
+  margin: 0;
+  border: none;
+  outline: none;
+  background: transparent;
+  color: #0D0D0D;
+  caret-color: #6210CC;
+  font-family: "Roboto Mono", monospace;
+  font-size: 13px;
+  line-height: 20px;
+  letter-spacing: -0.3px;
+}
+
+.jinja-condition-input::placeholder {
+  color: #A6A6A6;
+}
+`;
+var StyleManager = class {
+  static refCount = 0;
+  static styleEl = null;
+  static acquire() {
+    if (this.refCount++ > 0) return;
+    const existing = document.getElementById(STYLE_ID);
+    if (existing instanceof HTMLStyleElement) {
+      this.styleEl = existing;
+      return;
+    }
+    this.styleEl = document.createElement("style");
+    this.styleEl.id = STYLE_ID;
+    this.styleEl.textContent = JINJA_STYLES;
+    document.head.appendChild(this.styleEl);
+  }
+  static release() {
+    if (this.refCount === 0) return;
+    if (--this.refCount > 0) return;
+    if (this.styleEl?.parentNode) {
+      this.styleEl.remove();
+    }
+    this.styleEl = null;
+  }
+};
+function getBranchContext(view, nodePos) {
+  try {
+    const { doc: doc2 } = view.state;
+    const resolved = doc2.resolve(nodePos);
+    let blockDepth = -1;
+    for (let depth = resolved.depth; depth >= 0; depth--) {
+      if (resolved.node(depth).type.name === "jinjaIfBlock") {
+        blockDepth = depth;
+        break;
+      }
+    }
+    if (blockDepth < 0) {
+      return null;
+    }
+    const blockNode = resolved.node(blockDepth);
+    const blockPos = blockDepth === 0 ? 0 : resolved.before(blockDepth);
+    let branchOffset = blockPos + 1;
+    for (let index = 0; index < blockNode.childCount; index++) {
+      const branchNode = blockNode.child(index);
+      if (branchOffset === nodePos) {
+        return {
+          blockNode,
+          blockPos,
+          branchNode,
+          branchPos: branchOffset,
+          branchIndex: index
+        };
+      }
+      branchOffset += branchNode.nodeSize;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function isBranchBodyEmpty(node) {
+  if (node.childCount !== 1) return false;
+  const firstChild = node.firstChild;
+  return firstChild?.type.name === "paragraph" && firstChild.content.size === 0;
+}
+function isBranchNode(node) {
+  return node?.type.name === "jinjaIfBranch";
+}
+function createBranchNode(schema, branchType, condition) {
+  const branchNodeType = schema.nodes.jinjaIfBranch;
+  const paragraphNode = schema.nodes.paragraph?.createAndFill();
+  if (!branchNodeType || !paragraphNode) {
+    return null;
+  }
+  return branchNodeType.create(
+    {
+      branchType,
+      condition: branchType === "else" ? "" : condition
+    },
+    paragraphNode
+  );
+}
+function getLastBranchOfBlock(view, nodePos) {
+  const context = getBranchContext(view, nodePos);
+  if (!context || context.blockNode.childCount === 0) {
+    return null;
+  }
+  const index = context.blockNode.childCount - 1;
+  return {
+    index,
+    node: context.blockNode.child(index)
+  };
+}
+function getLastNonElseBranchIndex(view, nodePos) {
+  const context = getBranchContext(view, nodePos);
+  if (!context) return -1;
+  for (let i = context.blockNode.childCount - 1; i >= 0; i--) {
+    if (context.blockNode.child(i).attrs.branchType !== "else") return i;
+  }
+  return -1;
+}
+function getElseBranch(view, nodePos) {
+  const context = getBranchContext(view, nodePos);
+  if (!context) return false;
+  for (let index = 0; index < context.blockNode.childCount; index++) {
+    if (context.blockNode.child(index).attrs.branchType === "else") {
+      return true;
+    }
+  }
+  return false;
+}
+function deleteBlock(view, blockPos) {
+  const blockNode = view.state.doc.nodeAt(blockPos);
+  if (blockNode?.type.name !== "jinjaIfBlock") {
+    return false;
+  }
+  view.dispatch(view.state.tr.delete(blockPos, blockPos + blockNode.nodeSize).scrollIntoView());
+  view.focus();
+  return true;
+}
+function insertNewBranch(view, nodePos, branchType, condition = "") {
+  const context = getBranchContext(view, nodePos);
+  if (!context) return false;
+  if (context.branchNode.attrs.branchType === "else") return false;
+  const lastBranch = getLastBranchOfBlock(view, nodePos);
+  if (!lastBranch) return false;
+  if (branchType === "else") {
+    if (getElseBranch(view, nodePos)) return false;
+    if (lastBranch.index !== context.branchIndex) return false;
+  }
+  const newBranch = createBranchNode(view.state.schema, branchType, condition);
+  if (!newBranch) return false;
+  const insertPos = context.branchPos + context.branchNode.nodeSize;
+  view.dispatch(view.state.tr.insert(insertPos, newBranch).scrollIntoView());
+  view.focus();
+  return true;
+}
+function deleteBranch(view, nodePos, branchType) {
+  const context = getBranchContext(view, nodePos);
+  if (!context) return false;
+  if (branchType === "if") {
+    if (context.blockNode.childCount === 1) {
+      return deleteBlock(view, context.blockPos);
+    }
+    const nextBranch = context.blockNode.child(context.branchIndex + 1);
+    const promotedCondition = typeof nextBranch.attrs.condition === "string" ? nextBranch.attrs.condition : "";
+    const tr = view.state.tr.delete(context.branchPos, context.branchPos + context.branchNode.nodeSize);
+    tr.setNodeMarkup(context.branchPos, void 0, {
+      ...nextBranch.attrs,
+      branchType: "if",
+      condition: promotedCondition
+    });
+    view.dispatch(tr.scrollIntoView());
+    view.focus();
+    return true;
+  }
+  view.dispatch(view.state.tr.delete(context.branchPos, context.branchPos + context.branchNode.nodeSize).scrollIntoView());
+  view.focus();
+  return true;
+}
+function renderCondition(condition) {
+  const tokens = tokenizeCondition(condition);
+  const rendered = [];
+  for (let index = 0; index < tokens.length; index++) {
+    const token = tokens[index];
+    rendered.push(
+      /* @__PURE__ */ jsx6("span", { className: `jinja-token-${token.category}`, children: token.text }, `token-${index}-${token.start}`)
+    );
+  }
+  return rendered;
+}
+function ConditionDisplay({
+  branchType,
+  condition,
+  editable = true,
+  onConditionChange
+}) {
+  const [isEditing, setIsEditing] = useState2(false);
+  const [draftValue, setDraftValue] = useState2(condition);
+  const inputRef = useRef2(null);
+  useEffect2(() => {
+    if (!isEditing) {
+      setDraftValue(condition);
+    }
+  }, [condition, isEditing]);
+  useEffect2(() => {
+    if (isEditing) {
+      inputRef.current?.focus();
+      inputRef.current?.select();
+    }
+  }, [isEditing]);
+  if (branchType === "else") {
+    return /* @__PURE__ */ jsx6("span", { className: "jinja-otherwise", children: "Otherwise" });
+  }
+  const commit = () => {
+    setIsEditing(false);
+    if (draftValue !== condition) {
+      onConditionChange(draftValue);
+    }
+  };
+  const cancel = () => {
+    setDraftValue(condition);
+    setIsEditing(false);
+  };
+  if (isEditing && editable) {
+    return /* @__PURE__ */ jsx6(
+      "input",
+      {
+        ref: inputRef,
+        className: "jinja-condition-input",
+        value: draftValue,
+        placeholder: CONDITION_PLACEHOLDER,
+        onChange: (event) => setDraftValue(event.target.value),
+        onBlur: commit,
+        onKeyDown: (event) => {
+          if (event.key === "Enter") {
+            event.preventDefault();
+            commit();
+          }
+          if (event.key === "Escape") {
+            event.preventDefault();
+            cancel();
+          }
+        }
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx6(
+    "button",
+    {
+      type: "button",
+      className: "jinja-branch-condition",
+      onMouseDown: (event) => event.preventDefault(),
+      onClick: () => {
+        if (editable) {
+          setDraftValue(condition);
+          setIsEditing(true);
+        }
+      },
+      children: condition.length > 0 ? renderCondition(condition) : /* @__PURE__ */ jsx6("span", { className: "jinja-condition-placeholder", children: CONDITION_PLACEHOLDER })
+    }
+  );
+}
+function BranchPopupMenu({ items, position }) {
+  return /* @__PURE__ */ jsx6(
+    "div",
+    {
+      className: "jinja-popup-menu",
+      style: {
+        top: position.top,
+        left: position.left,
+        right: position.right
+      },
+      role: "menu",
+      children: items.map((item) => /* @__PURE__ */ jsx6(
+        "button",
+        {
+          type: "button",
+          className: "jinja-popup-item",
+          disabled: item.disabled,
+          onMouseDown: (event) => event.preventDefault(),
+          onClick: () => {
+            if (!item.disabled) {
+              item.onSelect();
+            }
+          },
+          role: "menuitem",
+          children: item.label
+        },
+        item.label
+      ))
+    }
+  );
+}
+function JinjaBranchHeader({
+  branchType,
+  condition,
+  editable = true,
+  onConditionChange,
+  onDelete,
+  onAddBranch,
+  isLastBranch,
+  hasElseBranch
+}) {
+  const [menuSource, setMenuSource] = useState2(null);
+  const kebabRef = useRef2(null);
+  const footerRef = useRef2(null);
+  useEffect2(() => {
+    if (!menuSource) return;
+    const handlePointerDown = (event) => {
+      const target = event.target;
+      if (!target) return;
+      if (kebabRef.current?.contains(target) || footerRef.current?.contains(target)) {
+        return;
+      }
+      setMenuSource(null);
+    };
+    const handleKeyDown = (event) => {
+      if (event.key === "Escape") {
+        setMenuSource(null);
+      }
+    };
+    document.addEventListener("pointerdown", handlePointerDown, true);
+    document.addEventListener("keydown", handleKeyDown);
+    return () => {
+      document.removeEventListener("pointerdown", handlePointerDown, true);
+      document.removeEventListener("keydown", handleKeyDown);
+    };
+  }, [menuSource]);
+  const menuItems = [];
+  const isOnlyIfBranch = branchType === "if" && isLastBranch && !hasElseBranch;
+  const canAddElif = editable && branchType !== "else" && (branchType === "elif" || isLastBranch);
+  const canAddElse = editable && branchType !== "else" && isLastBranch && !hasElseBranch;
+  if (canAddElif) {
+    menuItems.push({
+      label: "Else if",
+      onSelect: () => onAddBranch("elif")
+    });
+  }
+  if (canAddElse) {
+    menuItems.push({
+      label: "Else",
+      onSelect: () => onAddBranch("else")
+    });
+  }
+  if (editable) {
+    menuItems.push({
+      label: isOnlyIfBranch ? "Delete all" : "Delete",
+      onSelect: onDelete
+    });
+  }
+  const canOpenFooterMenu = editable && isLastBranch && branchType !== "else";
+  const isMenuOpen = (source) => menuSource === source && menuItems.length > 0;
+  return /* @__PURE__ */ jsxs5(Fragment2, { children: [
+    /* @__PURE__ */ jsxs5("div", { className: "jinja-branch-header", children: [
+      /* @__PURE__ */ jsx6("span", { className: `jinja-branch-badge jinja-branch-badge-${branchType}`, children: branchType === "elif" ? "ELSE IF" : branchType.toUpperCase() }),
+      /* @__PURE__ */ jsx6(
+        ConditionDisplay,
+        {
+          branchType,
+          condition,
+          editable,
+          onConditionChange
+        }
+      ),
+      editable ? /* @__PURE__ */ jsxs5("div", { className: "jinja-branch-actions", ref: kebabRef, children: [
+        /* @__PURE__ */ jsx6(
+          "button",
+          {
+            type: "button",
+            className: "jinja-ghost-btn",
+            "aria-label": `${branchType} branch options`,
+            onMouseDown: (event) => event.preventDefault(),
+            onClick: () => {
+              if (menuItems.length > 0) {
+                setMenuSource((current) => current === "kebab" ? null : "kebab");
+              }
+            },
+            children: /* @__PURE__ */ jsxs5("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "currentColor", children: [
+              /* @__PURE__ */ jsx6("circle", { cx: "8", cy: "3", r: "1.5" }),
+              /* @__PURE__ */ jsx6("circle", { cx: "8", cy: "8", r: "1.5" }),
+              /* @__PURE__ */ jsx6("circle", { cx: "8", cy: "13", r: "1.5" })
+            ] })
+          }
+        ),
+        isMenuOpen("kebab") ? /* @__PURE__ */ jsx6(
+          BranchPopupMenu,
+          {
+            position: { top: 28, right: 0 },
+            items: menuItems.map((item) => ({
+              ...item,
+              onSelect: () => {
+                setMenuSource(null);
+                item.onSelect();
+              }
+            }))
+          }
+        ) : null
+      ] }) : null
+    ] }),
+    isLastBranch ? /* @__PURE__ */ jsx6("div", { className: "jinja-add-footer", children: /* @__PURE__ */ jsx6("div", { className: "jinja-add-footer-col", children: /* @__PURE__ */ jsxs5("div", { className: "jinja-add-footer-actions", ref: footerRef, children: [
+      /* @__PURE__ */ jsx6(
+        "button",
+        {
+          type: "button",
+          className: "jinja-ghost-btn",
+          "aria-label": "Add branch",
+          disabled: !canOpenFooterMenu,
+          onMouseDown: (event) => event.preventDefault(),
+          onClick: () => {
+            if (canOpenFooterMenu && menuItems.length > 0) {
+              setMenuSource((current) => current === "footer" ? null : "footer");
+            }
+          },
+          children: /* @__PURE__ */ jsxs5("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", children: [
+            /* @__PURE__ */ jsx6("line", { x1: "8", y1: "3", x2: "8", y2: "13" }),
+            /* @__PURE__ */ jsx6("line", { x1: "3", y1: "8", x2: "13", y2: "8" })
+          ] })
+        }
+      ),
+      isMenuOpen("footer") ? /* @__PURE__ */ jsx6(
+        BranchPopupMenu,
+        {
+          position: { top: 28, left: 0 },
+          items: menuItems.filter((item) => item.label === "Else if" || item.label === "Else").map((item) => ({
+            ...item,
+            onSelect: () => {
+              setMenuSource(null);
+              item.onSelect();
+            }
+          }))
+        }
+      ) : null
+    ] }) }) }) : null
+  ] });
+}
+var JinjaIfBlockView = class {
+  dom;
+  contentDOM;
+  constructor() {
+    this.dom = document.createElement("div");
+    this.dom.className = "jinja-if-block";
+    this.dom.setAttribute("data-jinja-if-block", "");
+    this.contentDOM = this.dom;
+    requestAnimationFrame(() => this.notifyChildren());
+  }
+  notifyChildren() {
+    this.dom.querySelectorAll(".jinja-branch").forEach((el) => {
+      el.dispatchEvent(new CustomEvent("jinja-siblings-changed", { bubbles: false }));
+    });
+  }
+  update(node) {
+    if (node.type.name !== "jinjaIfBlock") return false;
+    requestAnimationFrame(() => this.notifyChildren());
+    return true;
+  }
+};
+var JinjaIfBranchView = class {
+  dom;
+  contentDOM;
+  headerContainer;
+  root;
+  node;
+  view;
+  getPos;
+  constructor(node, view, getPos) {
+    this.node = node;
+    this.view = view;
+    this.getPos = getPos;
+    StyleManager.acquire();
+    this.dom = document.createElement("div");
+    this.headerContainer = document.createElement("div");
+    const body = document.createElement("div");
+    const dividerColumn = document.createElement("div");
+    const divider = document.createElement("div");
+    this.dom.appendChild(this.headerContainer);
+    this.dom.appendChild(body);
+    this.headerContainer.className = "jinja-branch-controls";
+    this.headerContainer.contentEditable = "false";
+    body.className = "jinja-branch-body";
+    dividerColumn.className = "jinja-branch-divider-col";
+    dividerColumn.contentEditable = "false";
+    divider.className = "jinja-branch-divider";
+    dividerColumn.appendChild(divider);
+    this.contentDOM = document.createElement("div");
+    this.contentDOM.className = "jinja-branch-content";
+    this.contentDOM.setAttribute("data-placeholder", PLACEHOLDER_TEXT);
+    body.appendChild(dividerColumn);
+    body.appendChild(this.contentDOM);
+    this.root = createRoot2(this.headerContainer);
+    this._onSiblingsChanged = () => this.render();
+    this.dom.addEventListener("jinja-siblings-changed", this._onSiblingsChanged);
+    this.syncDOM();
+    this.render();
+  }
+  _onSiblingsChanged = null;
+  syncDOM() {
+    const branchType = this.node.attrs.branchType;
+    this.dom.className = `jinja-branch jinja-branch-${branchType}`;
+    this.dom.setAttribute("data-jinja-branch", "");
+    this.dom.setAttribute("data-branch-type", branchType);
+    this.dom.setAttribute("data-condition", String(this.node.attrs.condition ?? ""));
+    this.contentDOM.classList.toggle("jinja-branch-content-empty", isBranchBodyEmpty(this.node));
+  }
+  render() {
+    const nodePos = this.getPos();
+    if (nodePos == null) return;
+    const lastBranch = getLastBranchOfBlock(this.view, nodePos);
+    const context = getBranchContext(this.view, nodePos);
+    if (!lastBranch || !context) return;
+    const branchType = this.node.attrs.branchType;
+    const condition = String(this.node.attrs.condition ?? "");
+    const isLast = lastBranch.index === context.branchIndex;
+    const lastNonElseIdx = getLastNonElseBranchIndex(this.view, nodePos);
+    const showAddButton = context.branchIndex === lastNonElseIdx;
+    this.dom.classList.toggle("jinja-branch-last", isLast);
+    this.root.render(
+      /* @__PURE__ */ jsx6(
+        JinjaBranchHeader,
+        {
+          branchType,
+          condition,
+          editable: this.view.editable,
+          isLastBranch: showAddButton,
+          hasElseBranch: getElseBranch(this.view, nodePos),
+          onConditionChange: (value) => {
+            const currentPos = this.getPos();
+            if (currentPos == null) return;
+            this.view.dispatch(
+              this.view.state.tr.setNodeMarkup(currentPos, void 0, {
+                ...this.node.attrs,
+                condition: value
+              })
+            );
+            this.view.focus();
+          },
+          onDelete: () => {
+            const currentPos = this.getPos();
+            if (currentPos == null) return;
+            deleteBranch(this.view, currentPos, branchType);
+          },
+          onAddBranch: (nextBranchType) => {
+            const currentPos = this.getPos();
+            if (currentPos == null) return;
+            insertNewBranch(this.view, currentPos, nextBranchType, "");
+          }
+        }
+      )
+    );
+  }
+  update(node) {
+    if (!isBranchNode(node)) return false;
+    this.node = node;
+    this.syncDOM();
+    this.render();
+    return true;
+  }
+  stopEvent(event) {
+    const target = event.target;
+    return target != null && this.headerContainer.contains(target);
+  }
+  ignoreMutation(mutation) {
+    return this.headerContainer.contains(mutation.target);
+  }
+  destroy() {
+    if (this._onSiblingsChanged) {
+      this.dom.removeEventListener("jinja-siblings-changed", this._onSiblingsChanged);
+    }
+    StyleManager.release();
+    setTimeout(() => this.root.unmount(), 0);
+  }
+};
+function createJinjaIfBlockPlugin() {
+  return {
+    name: "jinjaIfBlock",
+    nodeViews: () => ({
+      jinjaIfBlock: (() => new JinjaIfBlockView()),
+      jinjaIfBranch: ((node, view, getPos) => new JinjaIfBranchView(node, view, getPos))
+    })
+  };
+}
+
 // src/ui/plugin/linkPlugin.ts
 import { InputRule as InputRule2, inputRules as inputRules2 } from "prosemirror-inputrules";
-import { Plugin as Plugin4, PluginKey as PluginKey4, TextSelection as TextSelection2 } from "prosemirror-state";
+import { Plugin as Plugin5, PluginKey as PluginKey5, TextSelection as TextSelection2 } from "prosemirror-state";
 var LINK_INPUT_RE = /\[([^\]]*)\]\(([^)\s]*?)(?:\s+"([^"]*)")?\)$/;
 var LINK_FULL_RE = /^\[([^\]]*)\]\(([^)\s]*?)(?:\s+"([^"]*)")?\)$/;
-var linkEditKey = new PluginKey4("linkEdit");
+var linkEditKey = new PluginKey5("linkEdit");
 function getMarkRange($pos, type) {
   const { parentOffset } = $pos;
   let child = $pos.parent.childAfter(parentOffset);
@@ -4541,7 +5750,7 @@ function explodeLinkToRaw(state) {
   return tr;
 }
 function createLinkEditPlugin() {
-  return new Plugin4({
+  return new Plugin5({
     key: linkEditKey,
     state: {
       init: () => ({ rawRange: null }),
@@ -4611,8 +5820,8 @@ function createLinkInputRule() {
   );
 }
 function createLinkClickPlugin() {
-  return new Plugin4({
-    key: new PluginKey4("linkClick"),
+  return new Plugin5({
+    key: new PluginKey5("linkClick"),
     props: {
       handleDOMEvents: {
         click: (_view, event) => {
@@ -4664,8 +5873,8 @@ function createLinkPlugin() {
 }
 
 // src/ui/plugin/dragHandlePlugin.ts
-import { Plugin as Plugin5, PluginKey as PluginKey5 } from "prosemirror-state";
-var PLUGIN_KEY = new PluginKey5("dragHandle");
+import { Plugin as Plugin6, PluginKey as PluginKey6 } from "prosemirror-state";
+var PLUGIN_KEY = new PluginKey6("dragHandle");
 var GRIP_SVG = `<svg width="12" height="12" viewBox="0 0 12 12" fill="currentColor" xmlns="http://www.w3.org/2000/svg">
   <circle cx="4" cy="2.5" r="1.2"/><circle cx="8" cy="2.5" r="1.2"/>
   <circle cx="4" cy="6" r="1.2"/><circle cx="8" cy="6" r="1.2"/>
@@ -4753,7 +5962,7 @@ var STYLES = (
 }
 `
 );
-var StyleManager = class {
+var StyleManager2 = class {
   static refCount = 0;
   static sheet = null;
   static styleEl = null;
@@ -4880,7 +6089,7 @@ var DragHandleController = class {
   globalCleanup = null;
   constructor(view) {
     this.view = view;
-    StyleManager.acquire();
+    StyleManager2.acquire();
     const parent = view.dom.parentNode;
     const pos = getComputedStyle(parent).position;
     if (pos === "static" || pos === "") parent.style.position = "relative";
@@ -4938,7 +6147,7 @@ var DragHandleController = class {
     }
     this.liveRegion.remove();
     this.layer.remove();
-    StyleManager.release();
+    StyleManager2.release();
   }
   // ── Private: update pipeline ──
   scheduleUpdate() {
@@ -5289,7 +6498,7 @@ function createDragHandlePlugin() {
     plugins: () => {
       let controller = null;
       return [
-        new Plugin5({
+        new Plugin6({
           key: PLUGIN_KEY,
           view(editorView) {
             controller = new DragHandleController(editorView);
@@ -5412,8 +6621,8 @@ function createTodoNodeViewPlugin() {
 }
 
 // src/ui/plugin/slashCommandPlugin.ts
-import { Plugin as Plugin6, PluginKey as PluginKey6 } from "prosemirror-state";
-var slashCommandKey = new PluginKey6("slashCommand");
+import { Plugin as Plugin7, PluginKey as PluginKey7 } from "prosemirror-state";
+var slashCommandKey = new PluginKey7("slashCommand");
 var TRIGGER_RE = /(?:^|\s)(\/[^\s]*)$/;
 function deriveState(state, dismissedFrom) {
   const { selection } = state;
@@ -5436,7 +6645,7 @@ function deriveState(state, dismissedFrom) {
   };
 }
 function createSlashCommandPlugin() {
-  const plugin = new Plugin6({
+  const plugin = new Plugin7({
     key: slashCommandKey,
     state: {
       init(_, state) {
@@ -5480,9 +6689,9 @@ function createSlashCommandPlugin() {
 }
 
 // src/ui/components/SlashCommandMenu.tsx
-import { useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
+import { useEffect as useEffect3, useRef as useRef3, useState as useState3 } from "react";
 import { createPortal } from "react-dom";
-import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
 function filterItems(items, query) {
   if (!query) return items;
   const q = query.toLowerCase();
@@ -5506,23 +6715,23 @@ var VPORT_MARGIN = 8;
 var MENU_WIDTH = 280;
 var MAX_MENU_H = 320;
 function SlashCommandMenu({ view, editorState, items }) {
-  const [selectedIndex, setSelectedIndex] = useState2(0);
-  const listRef = useRef2(null);
+  const [selectedIndex, setSelectedIndex] = useState3(0);
+  const listRef = useRef3(null);
   const pluginState = editorState ? slashCommandKey.getState(editorState) : void 0;
   const active = pluginState?.active ?? false;
   const range = pluginState?.range ?? null;
   const query = pluginState?.query ?? "";
   const filtered = filterItems(items, query);
-  useEffect2(() => {
+  useEffect3(() => {
     setSelectedIndex(0);
   }, [query, active]);
-  useEffect2(() => {
+  useEffect3(() => {
     const list = listRef.current;
     if (!list) return;
     const item = list.children[selectedIndex];
     item?.scrollIntoView({ block: "nearest" });
   }, [selectedIndex]);
-  useEffect2(() => {
+  useEffect3(() => {
     if (!active || !view) return;
     const onKeyDown = (e) => {
       if (e.key === "ArrowDown") {
@@ -5558,7 +6767,7 @@ function SlashCommandMenu({ view, editorState, items }) {
     top = coords.top - MAX_MENU_H - 4;
   }
   return createPortal(
-    /* @__PURE__ */ jsx6(
+    /* @__PURE__ */ jsx7(
       "div",
       {
         style: {
@@ -5575,7 +6784,7 @@ function SlashCommandMenu({ view, editorState, items }) {
           zIndex: 1100,
           animation: "ab-float-in 0.12s ease"
         },
-        children: /* @__PURE__ */ jsx6("div", { ref: listRef, children: filtered.length === 0 ? /* @__PURE__ */ jsx6(
+        children: /* @__PURE__ */ jsx7("div", { ref: listRef, children: filtered.length === 0 ? /* @__PURE__ */ jsx7(
           "div",
           {
             style: {
@@ -5585,7 +6794,7 @@ function SlashCommandMenu({ view, editorState, items }) {
             },
             children: "No results"
           }
-        ) : filtered.map((item, i) => /* @__PURE__ */ jsx6(
+        ) : filtered.map((item, i) => /* @__PURE__ */ jsx7(
           SlashMenuItem,
           {
             item,
@@ -5607,7 +6816,7 @@ function SlashCommandMenu({ view, editorState, items }) {
   );
 }
 function SlashMenuItem({ item, selected, onMouseEnter, onMouseDown }) {
-  return /* @__PURE__ */ jsxs5(
+  return /* @__PURE__ */ jsxs6(
     "button",
     {
       style: {
@@ -5623,7 +6832,7 @@ function SlashMenuItem({ item, selected, onMouseEnter, onMouseDown }) {
       onMouseEnter,
       onMouseDown,
       children: [
-        item.icon !== void 0 && /* @__PURE__ */ jsx6(
+        item.icon !== void 0 && /* @__PURE__ */ jsx7(
           "span",
           {
             style: {
@@ -5643,8 +6852,8 @@ function SlashMenuItem({ item, selected, onMouseEnter, onMouseDown }) {
             children: item.icon
           }
         ),
-        /* @__PURE__ */ jsxs5("span", { style: { display: "flex", flexDirection: "column", gap: 1, minWidth: 0 }, children: [
-          /* @__PURE__ */ jsx6(
+        /* @__PURE__ */ jsxs6("span", { style: { display: "flex", flexDirection: "column", gap: 1, minWidth: 0 }, children: [
+          /* @__PURE__ */ jsx7(
             "span",
             {
               style: {
@@ -5658,7 +6867,7 @@ function SlashMenuItem({ item, selected, onMouseEnter, onMouseDown }) {
               children: item.title
             }
           ),
-          item.description && /* @__PURE__ */ jsx6(
+          item.description && /* @__PURE__ */ jsx7(
             "span",
             {
               style: {
@@ -5678,8 +6887,8 @@ function SlashMenuItem({ item, selected, onMouseEnter, onMouseDown }) {
 }
 
 // src/ui/components/JinjaTreeView.tsx
-import { useState as useState3 } from "react";
-import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+import { useState as useState4 } from "react";
+import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
 var BRANCH_COLORS = {
   if: "#6366f1",
   elif: "#f59e0b",
@@ -5699,21 +6908,21 @@ function BranchNode({
   const blockCount = branch.blockEndIndex - branch.blockStartIndex;
   const preview = getBlockPreview(doc2, branch.blockStartIndex, branch.blockEndIndex);
   const connector = isLast ? "\u2514\u2500" : "\u251C\u2500";
-  return /* @__PURE__ */ jsxs6("div", { className: "jinja-tree-branch", children: [
-    /* @__PURE__ */ jsxs6("span", { className: "jinja-tree-connector", children: [
+  return /* @__PURE__ */ jsxs7("div", { className: "jinja-tree-branch", children: [
+    /* @__PURE__ */ jsxs7("span", { className: "jinja-tree-connector", children: [
       connector,
       " "
     ] }),
-    /* @__PURE__ */ jsxs6("span", { className: "jinja-tree-badge", style: { color, borderColor: color }, children: [
+    /* @__PURE__ */ jsxs7("span", { className: "jinja-tree-badge", style: { color, borderColor: color }, children: [
       "[",
       branch.type,
       "]"
     ] }),
-    branch.condition && /* @__PURE__ */ jsxs6("span", { className: "jinja-tree-condition", children: [
+    branch.condition && /* @__PURE__ */ jsxs7("span", { className: "jinja-tree-condition", children: [
       " ",
       branch.condition
     ] }),
-    /* @__PURE__ */ jsxs6("span", { className: "jinja-tree-meta", children: [
+    /* @__PURE__ */ jsxs7("span", { className: "jinja-tree-meta", children: [
       " ",
       blockCount,
       " block",
@@ -5723,23 +6932,23 @@ function BranchNode({
   ] });
 }
 function StructureNode({ structure, doc: doc2 }) {
-  const [expanded, setExpanded] = useState3(true);
+  const [expanded, setExpanded] = useState4(true);
   const firstBranch = structure.branches[0];
   const label = firstBranch?.condition ? `if ${firstBranch.condition}` : "if";
-  return /* @__PURE__ */ jsxs6("div", { className: "jinja-tree-structure", children: [
-    /* @__PURE__ */ jsxs6(
+  return /* @__PURE__ */ jsxs7("div", { className: "jinja-tree-structure", children: [
+    /* @__PURE__ */ jsxs7(
       "button",
       {
         className: "jinja-tree-toggle",
         onClick: () => setExpanded(!expanded),
         type: "button",
         children: [
-          /* @__PURE__ */ jsx7("span", { className: "jinja-tree-arrow", children: expanded ? "\u25BC" : "\u25B6" }),
-          /* @__PURE__ */ jsx7("span", { className: "jinja-tree-label", children: label })
+          /* @__PURE__ */ jsx8("span", { className: "jinja-tree-arrow", children: expanded ? "\u25BC" : "\u25B6" }),
+          /* @__PURE__ */ jsx8("span", { className: "jinja-tree-label", children: label })
         ]
       }
     ),
-    expanded && /* @__PURE__ */ jsx7("div", { className: "jinja-tree-branches", children: structure.branches.map((branch, i) => /* @__PURE__ */ jsx7(
+    expanded && /* @__PURE__ */ jsx8("div", { className: "jinja-tree-branches", children: structure.branches.map((branch, i) => /* @__PURE__ */ jsx8(
       BranchNode,
       {
         branch,
@@ -5753,15 +6962,15 @@ function StructureNode({ structure, doc: doc2 }) {
 function JinjaTreeView({ doc: doc2, className }) {
   const structures = analyzeJinjaBlocks(doc2);
   if (structures.length === 0) return null;
-  return /* @__PURE__ */ jsx7("div", { className: `jinja-tree ${className || ""}`, children: structures.map((structure) => /* @__PURE__ */ jsx7(StructureNode, { structure, doc: doc2 }, structure.id)) });
+  return /* @__PURE__ */ jsx8("div", { className: `jinja-tree ${className || ""}`, children: structures.map((structure) => /* @__PURE__ */ jsx8(StructureNode, { structure, doc: doc2 }, structure.id)) });
 }
 
 // src/ui/components/FloatingMenu.tsx
-import { useCallback as useCallback2, useEffect as useEffect3, useRef as useRef3, useState as useState4 } from "react";
+import { useCallback as useCallback2, useEffect as useEffect4, useRef as useRef4, useState as useState5 } from "react";
 import { createPortal as createPortal2 } from "react-dom";
 import { setBlockType, toggleMark as toggleMark2, wrapIn } from "prosemirror-commands";
 import { wrapInList as wrapInList2 } from "prosemirror-schema-list";
-import { Fragment as Fragment2, jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+import { Fragment as Fragment3, jsx as jsx9, jsxs as jsxs8 } from "react/jsx-runtime";
 var { paragraph: paragraph2, heading: heading2, bulletList: bulletList3, orderedList: orderedList3, blockquote: blockquote2 } = actionbookSchema.nodes;
 var {
   bold: bold2,
@@ -5849,8 +7058,8 @@ var BTN_RESET2 = {
   lineHeight: 1
 };
 function TBtn({ children, active, title, onMouseDown, style }) {
-  const [hover, setHover] = useState4(false);
-  return /* @__PURE__ */ jsx8(
+  const [hover, setHover] = useState5(false);
+  return /* @__PURE__ */ jsx9(
     "button",
     {
       ...{ [FLOAT_ATTR]: "" },
@@ -5881,13 +7090,13 @@ function TBtn({ children, active, title, onMouseDown, style }) {
   );
 }
 function Divider() {
-  return /* @__PURE__ */ jsx8("div", { style: { width: 1, height: 18, background: "rgba(0,0,0,0.07)", margin: "0 2px", flexShrink: 0 } });
+  return /* @__PURE__ */ jsx9("div", { style: { width: 1, height: 18, background: "rgba(0,0,0,0.07)", margin: "0 2px", flexShrink: 0 } });
 }
 function BlockTypeDropdown({ view, state, label }) {
-  const [open, setOpen] = useState4(false);
-  const btnRef = useRef3(null);
-  const [hover, setHover] = useState4(false);
-  useEffect3(() => {
+  const [open, setOpen] = useState5(false);
+  const btnRef = useRef4(null);
+  const [hover, setHover] = useState5(false);
+  useEffect4(() => {
     if (!open) return;
     const onDown = (e) => {
       if (!e.target.closest(`[${FLOAT_ATTR}]`)) {
@@ -5940,8 +7149,8 @@ function BlockTypeDropdown({ view, state, label }) {
     } }
   ];
   const btnRect = btnRef.current?.getBoundingClientRect();
-  return /* @__PURE__ */ jsxs7(Fragment2, { children: [
-    /* @__PURE__ */ jsxs7(
+  return /* @__PURE__ */ jsxs8(Fragment3, { children: [
+    /* @__PURE__ */ jsxs8(
       "button",
       {
         ref: btnRef,
@@ -5969,12 +7178,12 @@ function BlockTypeDropdown({ view, state, label }) {
         },
         children: [
           label,
-          /* @__PURE__ */ jsx8("span", { style: { fontSize: 8, opacity: 0.6 }, children: "\u25BE" })
+          /* @__PURE__ */ jsx9("span", { style: { fontSize: 8, opacity: 0.6 }, children: "\u25BE" })
         ]
       }
     ),
     open && btnRect && createPortal2(
-      /* @__PURE__ */ jsx8(
+      /* @__PURE__ */ jsx9(
         "div",
         {
           ...{ [FLOAT_ATTR]: "" },
@@ -5990,7 +7199,7 @@ function BlockTypeDropdown({ view, state, label }) {
             minWidth: 168,
             animation: "ab-float-in 0.12s ease"
           },
-          children: items.map((item) => /* @__PURE__ */ jsx8(DropdownItem, { item, onRun: () => setOpen(false) }, item.label))
+          children: items.map((item) => /* @__PURE__ */ jsx9(DropdownItem, { item, onRun: () => setOpen(false) }, item.label))
         }
       ),
       document.body
@@ -5998,8 +7207,8 @@ function BlockTypeDropdown({ view, state, label }) {
   ] });
 }
 function DropdownItem({ item, onRun }) {
-  const [hover, setHover] = useState4(false);
-  return /* @__PURE__ */ jsxs7(
+  const [hover, setHover] = useState5(false);
+  return /* @__PURE__ */ jsxs8(
     "button",
     {
       ...{ [FLOAT_ATTR]: "" },
@@ -6026,16 +7235,16 @@ function DropdownItem({ item, onRun }) {
         transition: "background 0.1s"
       },
       children: [
-        /* @__PURE__ */ jsx8("span", { style: { width: 24, flexShrink: 0, textAlign: "center", fontWeight: 700, fontSize: 12, fontFamily: "monospace", color: "#6366f1" }, children: item.shortLabel }),
+        /* @__PURE__ */ jsx9("span", { style: { width: 24, flexShrink: 0, textAlign: "center", fontWeight: 700, fontSize: 12, fontFamily: "monospace", color: "#6366f1" }, children: item.shortLabel }),
         item.label
       ]
     }
   );
 }
 function SelectionToolbar({ view, state, selectionRect }) {
-  const [linkMode, setLinkMode] = useState4(false);
-  const [linkHref, setLinkHref] = useState4("");
-  const inputRef = useRef3(null);
+  const [linkMode, setLinkMode] = useState5(false);
+  const [linkHref, setLinkHref] = useState5("");
+  const inputRef = useRef4(null);
   const isBold = hasMark(state, bold2);
   const isItalic = hasMark(state, italic2);
   const isUnderline = hasMark(state, underline2);
@@ -6087,7 +7296,7 @@ function SelectionToolbar({ view, state, selectionRect }) {
     view.dispatch(view.state.tr.removeMark(from, to, linkMark));
     view.focus();
   };
-  return /* @__PURE__ */ jsx8(
+  return /* @__PURE__ */ jsx9(
     "div",
     {
       ...{ [FLOAT_ATTR]: "" },
@@ -6110,9 +7319,9 @@ function SelectionToolbar({ view, state, selectionRect }) {
       },
       children: linkMode ? (
         /* ── Link input mode ── */
-        /* @__PURE__ */ jsxs7(Fragment2, { children: [
-          /* @__PURE__ */ jsx8("span", { style: { fontSize: 13, color: "#9ca3af", paddingLeft: 4, flexShrink: 0 }, children: "\u2197" }),
-          /* @__PURE__ */ jsx8(
+        /* @__PURE__ */ jsxs8(Fragment3, { children: [
+          /* @__PURE__ */ jsx9("span", { style: { fontSize: 13, color: "#9ca3af", paddingLeft: 4, flexShrink: 0 }, children: "\u2197" }),
+          /* @__PURE__ */ jsx9(
             "input",
             {
               ref: inputRef,
@@ -6143,7 +7352,7 @@ function SelectionToolbar({ view, state, selectionRect }) {
               }
             }
           ),
-          /* @__PURE__ */ jsx8(
+          /* @__PURE__ */ jsx9(
             TBtn,
             {
               title: "Apply (Enter)",
@@ -6155,7 +7364,7 @@ function SelectionToolbar({ view, state, selectionRect }) {
               children: "\u21B5"
             }
           ),
-          /* @__PURE__ */ jsx8(
+          /* @__PURE__ */ jsx9(
             TBtn,
             {
               title: "Cancel (Esc)",
@@ -6171,8 +7380,8 @@ function SelectionToolbar({ view, state, selectionRect }) {
         ] })
       ) : (
         /* ── Normal toolbar mode ── */
-        /* @__PURE__ */ jsxs7(Fragment2, { children: [
-          /* @__PURE__ */ jsx8(
+        /* @__PURE__ */ jsxs8(Fragment3, { children: [
+          /* @__PURE__ */ jsx9(
             TBtn,
             {
               active: isBold,
@@ -6182,7 +7391,7 @@ function SelectionToolbar({ view, state, selectionRect }) {
               children: "B"
             }
           ),
-          /* @__PURE__ */ jsx8(
+          /* @__PURE__ */ jsx9(
             TBtn,
             {
               active: isItalic,
@@ -6192,7 +7401,7 @@ function SelectionToolbar({ view, state, selectionRect }) {
               children: "I"
             }
           ),
-          /* @__PURE__ */ jsx8(
+          /* @__PURE__ */ jsx9(
             TBtn,
             {
               active: isUnderline,
@@ -6202,7 +7411,7 @@ function SelectionToolbar({ view, state, selectionRect }) {
               children: "U"
             }
           ),
-          /* @__PURE__ */ jsx8(
+          /* @__PURE__ */ jsx9(
             TBtn,
             {
               active: isStrike,
@@ -6212,7 +7421,7 @@ function SelectionToolbar({ view, state, selectionRect }) {
               children: "S"
             }
           ),
-          /* @__PURE__ */ jsx8(
+          /* @__PURE__ */ jsx9(
             TBtn,
             {
               active: isCode,
@@ -6222,7 +7431,7 @@ function SelectionToolbar({ view, state, selectionRect }) {
               children: "`\xB7`"
             }
           ),
-          /* @__PURE__ */ jsx8(
+          /* @__PURE__ */ jsx9(
             TBtn,
             {
               active: isLink,
@@ -6232,8 +7441,8 @@ function SelectionToolbar({ view, state, selectionRect }) {
               children: "\u2197"
             }
           ),
-          /* @__PURE__ */ jsx8(Divider, {}),
-          /* @__PURE__ */ jsx8(BlockTypeDropdown, { view, state, label: blockLabel })
+          /* @__PURE__ */ jsx9(Divider, {}),
+          /* @__PURE__ */ jsx9(BlockTypeDropdown, { view, state, label: blockLabel })
         ] })
       )
     }
@@ -6323,7 +7532,7 @@ var BLOCK_ITEMS = [
   }
 ];
 function EmptyParaHandle({ view, cursorPos }) {
-  const [menuOpen, setMenuOpen] = useState4(false);
+  const [menuOpen, setMenuOpen] = useState5(false);
   const coords = view.coordsAtPos(cursorPos);
   const lineH = Math.max(coords.bottom - coords.top, 18);
   const btnSize = 22;
@@ -6331,7 +7540,7 @@ function EmptyParaHandle({ view, cursorPos }) {
   const btnTop = coords.top + (lineH - btnSize) / 2;
   const menuLeft = Math.max(VPORT_MARGIN2, btnLeft);
   const menuTop = btnTop + btnSize + 4;
-  useEffect3(() => {
+  useEffect4(() => {
     if (!menuOpen) return;
     const onDown = (e) => {
       if (!e.target.closest(`[${FLOAT_ATTR}]`)) {
@@ -6341,8 +7550,8 @@ function EmptyParaHandle({ view, cursorPos }) {
     document.addEventListener("mousedown", onDown, true);
     return () => document.removeEventListener("mousedown", onDown, true);
   }, [menuOpen]);
-  return /* @__PURE__ */ jsxs7(Fragment2, { children: [
-    /* @__PURE__ */ jsx8(
+  return /* @__PURE__ */ jsxs8(Fragment3, { children: [
+    /* @__PURE__ */ jsx9(
       "button",
       {
         ...{ [FLOAT_ATTR]: "" },
@@ -6374,7 +7583,7 @@ function EmptyParaHandle({ view, cursorPos }) {
         children: "+"
       }
     ),
-    menuOpen && /* @__PURE__ */ jsx8(
+    menuOpen && /* @__PURE__ */ jsx9(
       "div",
       {
         ...{ [FLOAT_ATTR]: "" },
@@ -6390,7 +7599,7 @@ function EmptyParaHandle({ view, cursorPos }) {
           minWidth: 168,
           animation: "ab-float-in 0.12s ease"
         },
-        children: BLOCK_ITEMS.map((item) => /* @__PURE__ */ jsx8(
+        children: BLOCK_ITEMS.map((item) => /* @__PURE__ */ jsx9(
           BlockMenuItem,
           {
             item,
@@ -6408,8 +7617,8 @@ function BlockMenuItem({
   view,
   onRun
 }) {
-  const [hover, setHover] = useState4(false);
-  return /* @__PURE__ */ jsxs7(
+  const [hover, setHover] = useState5(false);
+  return /* @__PURE__ */ jsxs8(
     "button",
     {
       ...{ [FLOAT_ATTR]: "" },
@@ -6435,7 +7644,7 @@ function BlockMenuItem({
         transition: "background 0.1s"
       },
       children: [
-        /* @__PURE__ */ jsx8(
+        /* @__PURE__ */ jsx9(
           "span",
           {
             style: {
@@ -6456,11 +7665,11 @@ function BlockMenuItem({
   );
 }
 function FloatingMenu({ view, editorState }) {
-  const [showEmptyHandle, setShowEmptyHandle] = useState4(false);
-  const dwellTimerRef = useRef3(null);
-  const lastEmptyPosRef = useRef3(null);
-  const [, setScrollTick] = useState4(0);
-  useEffect3(() => {
+  const [showEmptyHandle, setShowEmptyHandle] = useState5(false);
+  const dwellTimerRef = useRef4(null);
+  const lastEmptyPosRef = useRef4(null);
+  const [, setScrollTick] = useState5(0);
+  useEffect4(() => {
     const editorDom = view?.dom;
     if (!editorDom) return;
     const container = editorDom.closest(".editor-shell") ?? editorDom.parentElement;
@@ -6469,7 +7678,7 @@ function FloatingMenu({ view, editorState }) {
     container.addEventListener("scroll", onScroll, { passive: true });
     return () => container.removeEventListener("scroll", onScroll);
   }, [view]);
-  useEffect3(() => {
+  useEffect4(() => {
     const id = "ab-float-keyframes";
     if (document.getElementById(id)) return;
     const style = document.createElement("style");
@@ -6499,8 +7708,8 @@ function FloatingMenu({ view, editorState }) {
   }
   const selectionRect = hasSelection ? getSelectionDOMRect() : null;
   return createPortal2(
-    /* @__PURE__ */ jsxs7(Fragment2, { children: [
-      hasSelection && selectionRect && /* @__PURE__ */ jsx8(
+    /* @__PURE__ */ jsxs8(Fragment3, { children: [
+      hasSelection && selectionRect && /* @__PURE__ */ jsx9(
         SelectionToolbar,
         {
           view,
@@ -6508,23 +7717,23 @@ function FloatingMenu({ view, editorState }) {
           selectionRect
         }
       ),
-      !hasSelection && showEmptyHandle && emptyPos !== null && /* @__PURE__ */ jsx8(EmptyParaHandle, { view, cursorPos: emptyPos })
+      !hasSelection && showEmptyHandle && emptyPos !== null && /* @__PURE__ */ jsx9(EmptyParaHandle, { view, cursorPos: emptyPos })
     ] }),
     document.body
   );
 }
 
 // src/ui/plugin/inlineSuggestPlugin.ts
-import { Plugin as Plugin7, PluginKey as PluginKey7 } from "prosemirror-state";
-import { Decoration as Decoration3, DecorationSet as DecorationSet3 } from "prosemirror-view";
-var inlineSuggestKey = new PluginKey7("inlineSuggest");
+import { Plugin as Plugin8, PluginKey as PluginKey8 } from "prosemirror-state";
+import { Decoration as Decoration4, DecorationSet as DecorationSet4 } from "prosemirror-view";
+var inlineSuggestKey = new PluginKey8("inlineSuggest");
 var DEBOUNCE_MS = 600;
 function createInlineSuggestPlugin(provider, endpoint, options) {
   const { onContextChange } = options ?? {};
   return {
     name: "inlineSuggest",
     plugins: () => [
-      new Plugin7({
+      new Plugin8({
         key: inlineSuggestKey,
         state: {
           init: () => ({ suggestion: null, anchorPos: null }),
@@ -6540,13 +7749,13 @@ function createInlineSuggestPlugin(provider, endpoint, options) {
         props: {
           decorations(state) {
             const ps = inlineSuggestKey.getState(state);
-            if (!ps?.suggestion || !state.selection.empty) return DecorationSet3.empty;
+            if (!ps?.suggestion || !state.selection.empty) return DecorationSet4.empty;
             const ghost = document.createElement("span");
             ghost.textContent = ps.suggestion;
             ghost.style.cssText = "color: rgba(0,0,0,0.3); pointer-events: none; user-select: none;";
             ghost.setAttribute("aria-hidden", "true");
-            return DecorationSet3.create(state.doc, [
-              Decoration3.widget(state.selection.from, ghost, {
+            return DecorationSet4.create(state.doc, [
+              Decoration4.widget(state.selection.from, ghost, {
                 side: 1,
                 key: "inline-suggest"
               })
@@ -6687,12 +7896,15 @@ export {
   convertBlock2 as convertBlock,
   convertInline2 as convertInline,
   createDragHandlePlugin,
+  createHistoryPlugin,
   createInlineSuggestPlugin,
   createInlineToolTagNodeViewPlugin,
   createInputRulesPlugin,
   createJinjaDecorationPlugin,
+  createJinjaIfBlockPlugin,
   createJumpPointAdjacentPlugin,
   createJumpPointNodeViewPlugin,
+  createJumpPointValidationPlugin,
   createKeymapPlugin,
   createLinkPlugin,
   createMarkdownClipboardPlugin,
@@ -6700,6 +7912,8 @@ export {
   createReactNodeView,
   createSlashCommandPlugin,
   createTodoNodeViewPlugin,
+  hasBrokenAnchorRefs,
+  hasDuplicateJumpPoints,
   inlineSuggestKey,
   slashCommandKey,
   toProseMirrorJSON,