@sendbird/actionbook-core 0.10.0 → 0.10.2

package/dist/ui/index.js

@@ -2020,7 +2020,7 @@ function resourceTagToMarkdown() {
 }
 
 // src/markdown/plugins/jumpPoint.ts
-var JUMP_POINT_RE = /\^([A-Za-z_]+)\^/g;
+var JUMP_POINT_RE = /\^([\p{L}\p{N}_-]+)\^/gu;
 function splitTextWithJumpPoints(text2) {
   const results = [];
   let lastIndex = 0;
@@ -2677,7 +2677,7 @@ function useEditorView(config) {
     const view = new EditorView(container, {
       state,
       nodeViews,
-      editable: () => configRef.current.editable !== false,
+      editable: () => configRef.current.editable === true,
       dispatchTransaction(tr) {
         const newState = view.state.apply(tr);
         view.updateState(newState);
@@ -2733,13 +2733,87 @@ function useEditorView(config) {
 // src/ui/plugin/inputRulesPlugin.ts
 import { InputRule, textblockTypeInputRule, wrappingInputRule } from "prosemirror-inputrules";
 import { TextSelection } from "prosemirror-state";
+
+// src/ui/plugin/slashCommandPlugin.ts
+import { Plugin, PluginKey } from "prosemirror-state";
+var slashCommandKey = new PluginKey("slashCommand");
+var TRIGGER_RE = /(?:^|\s)(\/[^\s]*)$/;
+function deriveState(state, dismissedFrom) {
+  const inactive = { active: false, range: null, query: "", parentType: "" };
+  const { selection } = state;
+  if (!selection.empty) return inactive;
+  const { $from } = selection;
+  const parentType = $from.parent.type.name;
+  for (let d = $from.depth; d > 0; d--) {
+    if ($from.node(d).type.name === "noteBlock") return inactive;
+  }
+  const textBefore = $from.parent.textBetween(0, $from.parentOffset, "\n", "\0");
+  const match = TRIGGER_RE.exec(textBefore);
+  if (!match) return inactive;
+  const slashText = match[1];
+  const slashStartInParent = textBefore.lastIndexOf(slashText);
+  const from = $from.start() + slashStartInParent;
+  const to = $from.pos;
+  if (dismissedFrom === from) return inactive;
+  return {
+    active: true,
+    range: { from, to },
+    query: slashText.slice(1),
+    parentType
+  };
+}
+function createSlashCommandPlugin() {
+  const plugin = new Plugin({
+    key: slashCommandKey,
+    state: {
+      init(_, state) {
+        const derived = deriveState(state, null);
+        return { ...derived, _dismissedFrom: null };
+      },
+      apply(tr, prev, _old, newState) {
+        const meta = tr.getMeta(slashCommandKey);
+        let dismissedFrom = prev._dismissedFrom;
+        if (meta?.dismiss !== void 0) {
+          dismissedFrom = meta.dismiss;
+        } else if (dismissedFrom !== null) {
+          const derived2 = deriveState(newState, null);
+          if (derived2.active && derived2.range && derived2.range.from !== dismissedFrom) {
+            dismissedFrom = null;
+          }
+        }
+        const derived = deriveState(newState, dismissedFrom);
+        return { ...derived, _dismissedFrom: dismissedFrom };
+      }
+    }
+    // Expose only the public fields via the key
+    // (InternalState is a superset of SlashCommandState so reads work fine)
+  });
+  return {
+    name: "slashCommand",
+    plugins: () => [plugin],
+    keymap: () => ({
+      Escape: (state, dispatch) => {
+        const s = slashCommandKey.getState(state);
+        if (!s?.active || !s.range) return false;
+        if (dispatch) {
+          const tr = state.tr;
+          tr.setMeta(slashCommandKey, { dismiss: s.range.from });
+          dispatch(tr);
+        }
+        return true;
+      }
+    })
+  };
+}
+
+// src/ui/plugin/inputRulesPlugin.ts
 var HEADING_RE = /^(#{1,6})\s$/;
 var BLOCKQUOTE_RE = /^\s*>\s$/;
 var CODE_BLOCK_RE = /^```([a-zA-Z0-9]*)$/;
 var HR_RE = /^([-*_])\1{2,}$/;
 var BULLET_LIST_RE = /^\s*([-*])\s$/;
 var ORDERED_LIST_RE = /^(\d+)\.\s$/;
-var JUMP_POINT_RE2 = /\^([A-Za-z_]+)\^$/;
+var JUMP_POINT_RE2 = /\^([\p{L}\p{N}_-]+)\^$/u;
 var BOLD_STAR_RE = /(?:^|[^*])\*\*([^*]+)\*\*$/;
 var BOLD_UNDER_RE = /(?:^|[^_])__([^_]+)__$/;
 var ITALIC_STAR_RE = /(?:^|[^*])\*([^*]+)\*$/;
@@ -2806,6 +2880,8 @@ function handleListInputRule(state, start, end, listType, attrs) {
 }
 function markInputRule(pattern, markType, markerLen) {
   return new InputRule(pattern, (state, match, start, end) => {
+    const slashState = slashCommandKey.getState(state);
+    if (slashState?.active) return null;
     const textContent2 = match[1];
     const fullMatch = match[0];
     const markedLength = markerLen * 2 + textContent2.length;
@@ -3298,9 +3374,20 @@ var enterCommand = chainCommands(
 );
 var shiftEnterCommand = (state, dispatch) => {
   if (dispatch) {
-    dispatch(
-      state.tr.replaceSelectionWith(hardBreak.create()).scrollIntoView()
-    );
+    const { from, to, $from } = state.selection;
+    const tr = state.tr;
+    if (from !== to) tr.delete(from, to);
+    const insertPos = tr.mapping.map(from);
+    const marks = $from.marks();
+    tr.insert(insertPos, hardBreak.create());
+    const afterBr = insertPos + 1;
+    tr.insertText("\u200B", afterBr);
+    const cursorPos = afterBr + 1;
+    if (cursorPos <= tr.doc.content.size) {
+      tr.setSelection(TextSelection2.create(tr.doc, cursorPos));
+    }
+    if (marks.length > 0) tr.setStoredMarks(marks);
+    dispatch(tr.scrollIntoView());
   }
   return true;
 };
@@ -3327,7 +3414,7 @@ function createKeymapPlugin() {
 
 // src/ui/plugin/markdownClipboard.ts
 import { DOMParser as ProseMirrorDOMParser, Fragment, Slice } from "prosemirror-model";
-import { Plugin, PluginKey } from "prosemirror-state";
+import { Plugin as Plugin2, PluginKey as PluginKey2 } from "prosemirror-state";
 
 // src/ast/traverse.ts
 var MAX_DEPTH3 = 128;
@@ -5062,6 +5149,320 @@ function analyzeJinjaBlocks(doc2) {
   });
 }
 
+// src/jinja/evaluator.ts
+var KEYWORDS2 = {
+  and: "AND",
+  or: "OR",
+  not: "NOT",
+  in: "IN",
+  is: "IS",
+  True: "BOOL",
+  False: "BOOL",
+  true: "BOOL",
+  false: "BOOL",
+  None: "NONE",
+  null: "NONE"
+};
+function tokenize(input) {
+  const tokens = [];
+  let i = 0;
+  while (i < input.length) {
+    if (/\s/.test(input[i])) {
+      i++;
+      continue;
+    }
+    if (input[i] === '"' || input[i] === "'") {
+      const quote = input[i];
+      let str = "";
+      i++;
+      while (i < input.length && input[i] !== quote) {
+        if (input[i] === "\\" && i + 1 < input.length) {
+          str += input[i + 1];
+          i += 2;
+        } else {
+          str += input[i];
+          i++;
+        }
+      }
+      if (i >= input.length) return { tokens: [], error: "Unterminated string literal" };
+      i++;
+      tokens.push({ type: "STRING", value: str });
+      continue;
+    }
+    if (/[0-9]/.test(input[i]) || input[i] === "-" && i + 1 < input.length && /[0-9]/.test(input[i + 1]) && (tokens.length === 0 || ["AND", "OR", "NOT", "EQ", "NEQ", "LT", "GT", "LTE", "GTE", "LPAREN", "IN", "IS"].includes(tokens[tokens.length - 1].type))) {
+      let num = "";
+      if (input[i] === "-") {
+        num = "-";
+        i++;
+      }
+      while (i < input.length && /[0-9]/.test(input[i])) {
+        num += input[i];
+        i++;
+      }
+      if (i < input.length && input[i] === ".") {
+        num += ".";
+        i++;
+        while (i < input.length && /[0-9]/.test(input[i])) {
+          num += input[i];
+          i++;
+        }
+      }
+      tokens.push({ type: "NUMBER", value: num });
+      continue;
+    }
+    if (/[a-zA-Z_]/.test(input[i])) {
+      let ident = "";
+      while (i < input.length && /[a-zA-Z0-9_.]/.test(input[i])) {
+        ident += input[i];
+        i++;
+      }
+      const kwType = KEYWORDS2[ident];
+      if (kwType) {
+        tokens.push({ type: kwType, value: ident });
+      } else {
+        tokens.push({ type: "IDENT", value: ident });
+      }
+      continue;
+    }
+    if (i + 1 < input.length) {
+      const two = input[i] + input[i + 1];
+      if (two === "==") {
+        tokens.push({ type: "EQ", value: "==" });
+        i += 2;
+        continue;
+      }
+      if (two === "!=") {
+        tokens.push({ type: "NEQ", value: "!=" });
+        i += 2;
+        continue;
+      }
+      if (two === "<=") {
+        tokens.push({ type: "LTE", value: "<=" });
+        i += 2;
+        continue;
+      }
+      if (two === ">=") {
+        tokens.push({ type: "GTE", value: ">=" });
+        i += 2;
+        continue;
+      }
+    }
+    if (input[i] === "<") {
+      tokens.push({ type: "LT", value: "<" });
+      i++;
+      continue;
+    }
+    if (input[i] === ">") {
+      tokens.push({ type: "GT", value: ">" });
+      i++;
+      continue;
+    }
+    if (input[i] === "(") {
+      tokens.push({ type: "LPAREN", value: "(" });
+      i++;
+      continue;
+    }
+    if (input[i] === ")") {
+      tokens.push({ type: "RPAREN", value: ")" });
+      i++;
+      continue;
+    }
+    return { tokens: [], error: `Unexpected character: ${input[i]}` };
+  }
+  tokens.push({ type: "EOF", value: "" });
+  return { tokens };
+}
+var Parser = class {
+  pos = 0;
+  tokens;
+  variables;
+  constructor(tokens, variables) {
+    this.tokens = tokens;
+    this.variables = variables;
+  }
+  peek() {
+    return this.tokens[this.pos] ?? { type: "EOF", value: "" };
+  }
+  advance() {
+    const t = this.tokens[this.pos];
+    this.pos++;
+    return t;
+  }
+  expect(type) {
+    const t = this.peek();
+    if (t.type !== type) {
+      throw new Error(`Expected ${type}, got ${t.type}`);
+    }
+    return this.advance();
+  }
+  // Grammar (precedence low→high):
+  //   expr     → or_expr
+  //   or_expr  → and_expr ('or' and_expr)*
+  //   and_expr → not_expr ('and' not_expr)*
+  //   not_expr → 'not' not_expr | cmp_expr
+  //   cmp_expr → primary (('=='|'!='|'<'|'>'|'<='|'>='|'in'|'is'|'is not') primary)?
+  //   primary  → STRING | NUMBER | BOOL | NONE | IDENT | '(' expr ')'
+  evaluate() {
+    const result = this.orExpr();
+    if (this.peek().type !== "EOF") {
+      throw new Error(`Unexpected token: ${this.peek().value}`);
+    }
+    return result;
+  }
+  orExpr() {
+    let left = this.andExpr();
+    while (this.peek().type === "OR") {
+      this.advance();
+      const right = this.andExpr();
+      left = isTruthy(left) || isTruthy(right);
+    }
+    return left;
+  }
+  andExpr() {
+    let left = this.notExpr();
+    while (this.peek().type === "AND") {
+      this.advance();
+      const right = this.notExpr();
+      left = isTruthy(left) && isTruthy(right);
+    }
+    return left;
+  }
+  notExpr() {
+    if (this.peek().type === "NOT") {
+      this.advance();
+      const val = this.notExpr();
+      return !isTruthy(val);
+    }
+    return this.cmpExpr();
+  }
+  cmpExpr() {
+    const left = this.primary();
+    const op = this.peek().type;
+    switch (op) {
+      case "EQ":
+        this.advance();
+        return looseEqual(left, this.primary());
+      case "NEQ":
+        this.advance();
+        return !looseEqual(left, this.primary());
+      case "LT":
+        this.advance();
+        return toNumber(left) < toNumber(this.primary());
+      case "GT":
+        this.advance();
+        return toNumber(left) > toNumber(this.primary());
+      case "LTE":
+        this.advance();
+        return toNumber(left) <= toNumber(this.primary());
+      case "GTE":
+        this.advance();
+        return toNumber(left) >= toNumber(this.primary());
+      case "IN": {
+        this.advance();
+        const collection = this.primary();
+        if (Array.isArray(collection)) {
+          return collection.some((item) => looseEqual(item, left));
+        }
+        if (typeof collection === "string" && typeof left === "string") {
+          return collection.includes(left);
+        }
+        return false;
+      }
+      case "IS": {
+        this.advance();
+        if (this.peek().type === "NOT") {
+          this.advance();
+          return !looseEqual(left, this.primary());
+        }
+        return looseEqual(left, this.primary());
+      }
+      default:
+        return left;
+    }
+  }
+  primary() {
+    const t = this.peek();
+    switch (t.type) {
+      case "STRING":
+        this.advance();
+        return t.value;
+      case "NUMBER":
+        this.advance();
+        return parseFloat(t.value);
+      case "BOOL":
+        this.advance();
+        return t.value === "True" || t.value === "true";
+      case "NONE":
+        this.advance();
+        return null;
+      case "IDENT": {
+        this.advance();
+        return this.resolveVariable(t.value);
+      }
+      case "LPAREN": {
+        this.advance();
+        const val = this.orExpr();
+        this.expect("RPAREN");
+        return val;
+      }
+      default:
+        throw new Error(`Unexpected token in primary: ${t.type} "${t.value}"`);
+    }
+  }
+  resolveVariable(name) {
+    const entry = this.variables.get(name);
+    if (entry === void 0) {
+      return null;
+    }
+    switch (entry.type) {
+      case "string":
+        return String(entry.value);
+      case "number":
+        return Number(entry.value);
+      case "boolean":
+        return entry.value === true || entry.value === "true";
+      default:
+        return String(entry.value);
+    }
+  }
+};
+function isTruthy(v) {
+  if (v === null || v === void 0) return false;
+  if (typeof v === "boolean") return v;
+  if (typeof v === "number") return v !== 0;
+  if (typeof v === "string") return v.length > 0;
+  if (Array.isArray(v)) return v.length > 0;
+  return true;
+}
+function looseEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null) return a === b;
+  if (typeof a === "number" && typeof b === "string") return a === parseFloat(b);
+  if (typeof a === "string" && typeof b === "number") return parseFloat(a) === b;
+  return false;
+}
+function toNumber(v) {
+  if (typeof v === "number") return v;
+  if (typeof v === "string") return parseFloat(v) || 0;
+  if (typeof v === "boolean") return v ? 1 : 0;
+  return 0;
+}
+function validateCondition(condition) {
+  const trimmed = condition.trim();
+  if (trimmed === "") return { valid: true };
+  const { tokens, error: tokenError } = tokenize(trimmed);
+  if (tokenError) return { valid: false, error: tokenError };
+  if (tokens.length === 0) return { valid: false, error: "Empty expression" };
+  try {
+    const parser = new Parser(tokens, /* @__PURE__ */ new Map());
+    parser.evaluate();
+    return { valid: true };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : "Invalid expression";
+    return { valid: false, error: msg };
+  }
+}
+
 // src/tree/documentTree.ts
 var MAX_DEPTH6 = 128;
 var END_ACTION_RESOURCE_IDS = /* @__PURE__ */ new Set([
@@ -5210,7 +5611,7 @@ function buildDocumentTree(doc2) {
 }
 
 // src/ui/plugin/markdownClipboard.ts
-var key = new PluginKey("markdownClipboard");
+var key = new PluginKey2("markdownClipboard");
 var MAX_PASTE_LIST_DEPTH = 3;
 var MAX_FLATTEN_DEPTH = 128;
 function flattenDeepLists(node, listDepth = 0, _recurseDepth = 0) {
@@ -5273,7 +5674,7 @@ function textToSlice(text2, view) {
     view.state.doc.descendants((node) => {
       if (node.type.name === "jumpPoint") existingIds.add(node.attrs.id);
     });
-    const deduped = text2.replace(/\^([A-Za-z_][A-Za-z0-9_]*)\^/gm, (match, id) => {
+    const deduped = text2.replace(/\^([\p{L}\p{N}_-]+)\^/gmu, (match, id) => {
       if (existingIds.has(id)) return id;
       existingIds.add(id);
       return match;
@@ -5290,7 +5691,7 @@ function textToSlice(text2, view) {
 }
 var URL_RE = /^https?:\/\/[^\s]+$/i;
 function createPlugin() {
-  return new Plugin({
+  return new Plugin2({
     key,
     props: {
       handlePaste(view, event) {
@@ -5356,9 +5757,9 @@ function createMarkdownClipboardPlugin() {
 }
 
 // src/ui/plugin/jumpPointPlugin.ts
-import { Plugin as Plugin2, PluginKey as PluginKey2, TextSelection as TextSelection3 } from "prosemirror-state";
+import { Plugin as Plugin3, PluginKey as PluginKey3, TextSelection as TextSelection3 } from "prosemirror-state";
 import { Decoration, DecorationSet } from "prosemirror-view";
-var adjacentKey = new PluginKey2("jumpPointAdjacent");
+var adjacentKey = new PluginKey3("jumpPointAdjacent");
 var JUMP_POINT_ADJACENT_SPEC = { jumpPointAdjacent: true };
 function buildDecorations(state) {
   const { selection } = state;
@@ -5374,10 +5775,10 @@ function buildDecorations(state) {
   });
   return DecorationSet.create(state.doc, decorations);
 }
-var jumpPointEditKey = new PluginKey2("jumpPointEdit");
-var JUMP_POINT_FULL_RE = /^\^([A-Za-z_][A-Za-z0-9_]*)\^$/;
+var jumpPointEditKey = new PluginKey3("jumpPointEdit");
+var JUMP_POINT_FULL_RE = /^\^([\p{L}\p{N}_-]+)\^$/u;
 function createJumpPointEditPlugin() {
-  return new Plugin2({
+  return new Plugin3({
     key: jumpPointEditKey,
     state: {
       init: () => ({ rawRange: null }),
@@ -5479,7 +5880,7 @@ function createJumpPointAdjacentPlugin() {
     }),
     plugins: () => [
       createJumpPointEditPlugin(),
-      new Plugin2({
+      new Plugin3({
         key: adjacentKey,
         state: {
           init(_, state) {
@@ -5645,9 +6046,9 @@ function createJumpPointNodeViewPlugin() {
 }
 
 // src/ui/plugin/jumpPointValidationPlugin.ts
-import { Plugin as Plugin3, PluginKey as PluginKey3 } from "prosemirror-state";
+import { Plugin as Plugin4, PluginKey as PluginKey4 } from "prosemirror-state";
 import { Decoration as Decoration2, DecorationSet as DecorationSet2 } from "prosemirror-view";
-var pluginKey = new PluginKey3("jumpPointValidation");
+var pluginKey = new PluginKey4("jumpPointValidation");
 function collectJumpPointIds(state) {
   const ids = /* @__PURE__ */ new Set();
   state.doc.descendants((node) => {
@@ -5697,7 +6098,7 @@ function createJumpPointValidationPlugin() {
   return {
     name: "jumpPointValidation",
     plugins: () => [
-      new Plugin3({
+      new Plugin4({
         key: pluginKey,
         state: {
           init(_, state) {
@@ -5813,9 +6214,9 @@ function createInlineToolTagNodeViewPlugin() {
 }
 
 // src/ui/plugin/jinjaDecoration.ts
-import { Plugin as Plugin4, PluginKey as PluginKey4 } from "prosemirror-state";
+import { Plugin as Plugin5, PluginKey as PluginKey5 } from "prosemirror-state";
 import { Decoration as Decoration3, DecorationSet as DecorationSet3 } from "prosemirror-view";
-var jinjaPluginKey = new PluginKey4("jinjaDecoration");
+var jinjaPluginKey = new PluginKey5("jinjaDecoration");
 var JINJA_TAG_RE = /\{%\s*(if|elif|else|endif)\s*([^%]*?)\s*%\}/g;
 function getBlockPositions(doc2) {
   const blocks = [];
@@ -5906,7 +6307,7 @@ function createJinjaDecorationPlugin() {
   return {
     name: "jinjaDecoration",
     plugins: () => [
-      new Plugin4({
+      new Plugin5({
         key: jinjaPluginKey,
         state: {
           init(_, state) {
@@ -5930,7 +6331,7 @@ function createJinjaDecorationPlugin() {
 // src/ui/plugin/jinjaIfBlockPlugin.tsx
 import { useEffect as useEffect2, useRef as useRef2, useState as useState3 } from "react";
 import { createRoot as createRoot2 } from "react-dom/client";
-import { Plugin as Plugin5, TextSelection as TextSelection4 } from "prosemirror-state";
+import { Plugin as Plugin6, TextSelection as TextSelection4 } from "prosemirror-state";
 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";
@@ -6029,6 +6430,18 @@ var JINJA_STYLES = `
   letter-spacing: -0.3px;
 }
 
+.jinja-branch-condition-invalid {
+  text-decoration: wavy underline #D9352C;
+  text-underline-offset: 3px;
+}
+
+.jinja-condition-error-icon {
+  color: #D9352C;
+  margin-left: 4px;
+  font-size: 12px;
+  flex-shrink: 0;
+}
+
 .jinja-token-variable {
   color: #4141B2;
 }
@@ -6477,11 +6890,14 @@ function ConditionDisplay({
       }
     );
   }
+  const validation = condition.length > 0 ? validateCondition(condition) : null;
+  const isInvalid = validation != null && !validation.valid;
   return /* @__PURE__ */ jsx6(
     "button",
     {
       type: "button",
-      className: "jinja-branch-condition",
+      className: `jinja-branch-condition${isInvalid ? " jinja-branch-condition-invalid" : ""}`,
+      title: isInvalid ? validation.error : void 0,
       onMouseDown: (event) => event.preventDefault(),
       onClick: () => {
         if (editable) {
@@ -6489,7 +6905,10 @@ function ConditionDisplay({
           setIsEditing(true);
         }
       },
-      children: condition.length > 0 ? renderCondition(condition) : /* @__PURE__ */ jsx6("span", { className: "jinja-condition-placeholder", children: CONDITION_PLACEHOLDER })
+      children: condition.length > 0 ? /* @__PURE__ */ jsxs5(Fragment2, { children: [
+        renderCondition(condition),
+        isInvalid && /* @__PURE__ */ jsx6("span", { className: "jinja-condition-error-icon", children: "\u26A0" })
+      ] }) : /* @__PURE__ */ jsx6("span", { className: "jinja-condition-placeholder", children: CONDITION_PLACEHOLDER })
     }
   );
 }
@@ -6766,7 +7185,7 @@ var JinjaIfBranchView = class {
         {
           branchType,
           condition,
-          editable: this.view.editable,
+          editable: this.view.editable && this.view.dom.getAttribute("contenteditable") !== "false",
           isLastBranch: showAddButton,
           hasElseBranch: context && nodePos != null ? getElseBranch(this.view, nodePos) : false,
           onConditionChange: (value) => {
@@ -6824,7 +7243,7 @@ var JinjaIfBranchView = class {
 };
 function createEditableWatcherPlugin() {
   let lastEditable = null;
-  return new Plugin5({
+  return new Plugin6({
     view(editorView) {
       lastEditable = editorView.editable;
       return {
@@ -6855,10 +7274,10 @@ function createJinjaIfBlockPlugin() {
 
 // src/ui/plugin/linkPlugin.ts
 import { InputRule as InputRule2, inputRules as inputRules2 } from "prosemirror-inputrules";
-import { Plugin as Plugin6, PluginKey as PluginKey5, TextSelection as TextSelection5 } from "prosemirror-state";
+import { Plugin as Plugin7, PluginKey as PluginKey6, TextSelection as TextSelection5 } from "prosemirror-state";
 var LINK_INPUT_RE = /\\?\[([^\]]*?)\\?\]\(([^)\s]*?)(?:\s+"([^"]*)")?\)$/;
 var LINK_FULL_RE = /^\\?\[([^\]]*?)\\?\]\(([^)\s]*?)(?:\s+"([^"]*)")?\)$/;
-var linkEditKey = new PluginKey5("linkEdit");
+var linkEditKey = new PluginKey6("linkEdit");
 function getMarkRange($pos, type) {
   const { parentOffset } = $pos;
   let child = $pos.parent.childAfter(parentOffset);
@@ -6906,7 +7325,7 @@ function explodeLinkToRaw(state) {
   return tr;
 }
 function createLinkEditPlugin() {
-  return new Plugin6({
+  return new Plugin7({
     key: linkEditKey,
     state: {
       init: () => ({ rawRange: null }),
@@ -6976,8 +7395,8 @@ function createLinkInputRule() {
   );
 }
 function createLinkClickPlugin() {
-  return new Plugin6({
-    key: new PluginKey5("linkClick"),
+  return new Plugin7({
+    key: new PluginKey6("linkClick"),
     props: {
       handleDOMEvents: {
         click: (_view, event) => {
@@ -7029,8 +7448,8 @@ function createLinkPlugin() {
 }
 
 // src/ui/plugin/dragHandlePlugin.ts
-import { Plugin as Plugin7, PluginKey as PluginKey6 } from "prosemirror-state";
-var PLUGIN_KEY = new PluginKey6("dragHandle");
+import { Plugin as Plugin8, PluginKey as PluginKey7 } from "prosemirror-state";
+var PLUGIN_KEY = new PluginKey7("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"/>
@@ -7837,7 +8256,7 @@ function createDragHandlePlugin() {
     plugins: () => {
       let controller = null;
       return [
-        new Plugin7({
+        new Plugin8({
           key: PLUGIN_KEY,
           view(editorView) {
             controller = new DragHandleController(editorView);
@@ -7960,10 +8379,10 @@ function createTodoNodeViewPlugin() {
 }
 
 // src/ui/plugin/placeholderPlugin.ts
-import { Plugin as Plugin8, PluginKey as PluginKey7 } from "prosemirror-state";
+import { Plugin as Plugin9, PluginKey as PluginKey8 } from "prosemirror-state";
 import { Decoration as Decoration4, DecorationSet as DecorationSet4 } from "prosemirror-view";
 var PLACEHOLDER_TEXT2 = "Type to start writing, or press  /  to insert an action.";
-var pluginKey2 = new PluginKey7("placeholder");
+var pluginKey2 = new PluginKey8("placeholder");
 function buildDecorations4(state) {
   const { doc: doc2, selection } = state;
   if (!selection.empty) return DecorationSet4.empty;
@@ -7989,7 +8408,7 @@ function createPlaceholderPlugin() {
   return {
     name: "placeholder",
     plugins: () => [
-      new Plugin8({
+      new Plugin9({
         key: pluginKey2,
         state: {
           init(_, state) {
@@ -8012,78 +8431,6 @@ function createPlaceholderPlugin() {
   };
 }
 
-// src/ui/plugin/slashCommandPlugin.ts
-import { Plugin as Plugin9, PluginKey as PluginKey8 } from "prosemirror-state";
-var slashCommandKey = new PluginKey8("slashCommand");
-var TRIGGER_RE = /(?:^|\s)(\/[^\s]*)$/;
-function deriveState(state, dismissedFrom) {
-  const inactive = { active: false, range: null, query: "", parentType: "" };
-  const { selection } = state;
-  if (!selection.empty) return inactive;
-  const { $from } = selection;
-  const parentType = $from.parent.type.name;
-  for (let d = $from.depth; d > 0; d--) {
-    if ($from.node(d).type.name === "noteBlock") return inactive;
-  }
-  const textBefore = $from.parent.textBetween(0, $from.parentOffset, "\n", "\0");
-  const match = TRIGGER_RE.exec(textBefore);
-  if (!match) return inactive;
-  const slashText = match[1];
-  const slashStartInParent = textBefore.lastIndexOf(slashText);
-  const from = $from.start() + slashStartInParent;
-  const to = $from.pos;
-  if (dismissedFrom === from) return inactive;
-  return {
-    active: true,
-    range: { from, to },
-    query: slashText.slice(1),
-    parentType
-  };
-}
-function createSlashCommandPlugin() {
-  const plugin = new Plugin9({
-    key: slashCommandKey,
-    state: {
-      init(_, state) {
-        const derived = deriveState(state, null);
-        return { ...derived, _dismissedFrom: null };
-      },
-      apply(tr, prev, _old, newState) {
-        const meta = tr.getMeta(slashCommandKey);
-        let dismissedFrom = prev._dismissedFrom;
-        if (meta?.dismiss !== void 0) {
-          dismissedFrom = meta.dismiss;
-        } else if (dismissedFrom !== null) {
-          const derived2 = deriveState(newState, null);
-          if (derived2.active && derived2.range && derived2.range.from !== dismissedFrom) {
-            dismissedFrom = null;
-          }
-        }
-        const derived = deriveState(newState, dismissedFrom);
-        return { ...derived, _dismissedFrom: dismissedFrom };
-      }
-    }
-    // Expose only the public fields via the key
-    // (InternalState is a superset of SlashCommandState so reads work fine)
-  });
-  return {
-    name: "slashCommand",
-    plugins: () => [plugin],
-    keymap: () => ({
-      Escape: (state, dispatch) => {
-        const s = slashCommandKey.getState(state);
-        if (!s?.active || !s.range) return false;
-        if (dispatch) {
-          const tr = state.tr;
-          tr.setMeta(slashCommandKey, { dismiss: s.range.from });
-          dispatch(tr);
-        }
-        return true;
-      }
-    })
-  };
-}
-
 // src/ui/components/SlashCommandMenu.tsx
 import React4, { useEffect as useEffect3, useLayoutEffect, useRef as useRef3, useState as useState4 } from "react";
 import { createPortal } from "react-dom";
@@ -9956,6 +10303,22 @@ function createInlineSuggestPlugin(provider, endpoint, options) {
     ]
   };
 }
+
+// src/ui/bridge/jinjaValidation.ts
+function hasInvalidJinjaConditions(state) {
+  let found = false;
+  state.doc.descendants((node) => {
+    if (found) return false;
+    if (node.type.name === "jinjaIfBranch") {
+      const condition = String(node.attrs.condition ?? "");
+      if (condition && !validateCondition(condition).valid) {
+        found = true;
+      }
+      return false;
+    }
+  });
+  return found;
+}
 export {
   ActionbookRenderer,
   DocumentTreeView,
@@ -9989,6 +10352,7 @@ export {
   createTodoNodeViewPlugin,
   hasBrokenAnchorRefs,
   hasDuplicateJumpPoints,
+  hasInvalidJinjaConditions,
   inlineSuggestKey,
   slashCommandKey,
   toProseMirrorJSON,