@sendbird/actionbook-core 0.7.2

package/README.md

@@ -0,0 +1,157 @@
+# actionbook-core
+
+Actionbook 문서의 프레임워크 독립적 코어 라이브러리.
+
+Tiptap/ProseMirror에 종속되지 않는 자체 AST 모델, 마크다운 파서/시리얼라이저, Jinja 조건식 평가기, 그리고 구조적 편집 Operation 시스템을 제공합니다.
+
+## 왜 필요한가
+
+기존 Actionbook 에디터의 문서 모델은 ProseMirror 스키마에 강하게 결합되어 있어서:
+
+- 서버 사이드에서 문서를 파싱/검증할 수 없음
+- 에디터를 교체하려면 데이터 모델까지 함께 바꿔야 함
+- Jinja 프리뷰 등 부가 기능이 에디터 DOM에 의존
+
+이 라이브러리는 순수 TypeScript로 작성되어 **브라우저, Node.js, 서버리스 환경** 어디서든 동작합니다.
+
+## 빠른 시작
+
+```typescript
+import {
+  parseMarkdown,
+  serializeToMarkdown,
+  fromProseMirrorJSON,
+  validate,
+  doc, paragraph, text, bold, resourceTag, jumpPoint,
+} from '@sb/actionbook-core';
+
+// 마크다운 파싱
+const ast = parseMarkdown('# Title\n\nUse {{tool:t1:My Tool}} at ^START^');
+
+// 빌더로 직접 생성
+const manual = doc(
+  paragraph(text('Hello '), text('bold', [bold()]), resourceTag('tool', 't1', 'Tool')),
+);
+
+// 스키마 검증
+const errors = validate(ast); // [] 이면 정상
+
+// 마크다운 출력
+const md = serializeToMarkdown(ast);
+
+// ProseMirror JSON 변환 (기존 editor_data 호환)
+const ast2 = fromProseMirrorJSON(existingEditorData);
+```
+
+## 모듈 구조
+
+| 모듈 | 설명 |
+|------|------|
+| `ast/` | 타입 정의, 빌더, 순회, 경로 주소 체계 |
+| `schema/` | AST 구조 검증 (URL 프로토콜 allowlist 포함) |
+| `markdown/` | mdast 기반 파서/시리얼라이저 + 커스텀 구문 플러그인 |
+| `json/` | v3 포맷 직렬화 + 레거시 자동 감지 역직렬화 |
+| `compat/` | ProseMirror JSONContent → AST 변환 |
+| `operations/` | 구조적 편집 (Insert/Delete/Replace + undo 지원) |
+| `jinja/` | 순수 텍스트 기반 Jinja 블록 파서 + 안전한 조건식 평가기 |
+| `utils/` | 리소스 태그 추출, 중복 Jump Point 탐지 |
+
+## 테스트
+
+```bash
+cd libs/actionbook-core
+npx vitest run
+```
+
+12개 파일, 206개 테스트. 커버리지: AST 빌더/순회, 마크다운 roundtrip, ProseMirror 호환, 스키마 검증, Jinja 평가기 보안 케이스, Operation 타입 안전성, 역직렬화 경계, URL 새니타이제이션.
+
+## 보안 설계
+
+이 라이브러리는 신뢰되지 않는 입력(사용자가 편집한 마크다운, 외부에서 전달된 editor_data)을 처리하도록 설계되었습니다.
+
+| 위협 | 대응 |
+|------|------|
+| Jinja 조건식을 통한 임의 코드 실행 | `new Function` / `eval` 제거. 재귀 하강 파서로 화이트리스트 연산자만 평가 |
+| 악의적 AST 주입 (malformed editor_data) | 모든 역직렬화 경계에서 `validate()` 강제 적용 |
+| `javascript:` URL을 통한 XSS | 파서, PM 변환기, 스키마 검증 3중 차단 (http/https/mailto/tel 만 허용) |
+| 깊게 중첩된 입력으로 stack overflow | 모든 재귀 함수에 MAX_DEPTH 가드 (128) |
+| Operation으로 잘못된 AST 생성 | 부모-자식 타입 매트릭스 검증 + 경로 유효성 체크 |
+
+## 현재 한계
+
+### 기존 에디터와 아직 통합되지 않음
+
+이 라이브러리는 독립 모듈로 동일성 테스트만 완료된 상태입니다. 기존 에디터 코드를 실제로 교체하는 작업은 아직 수행되지 않았으며, 점진적으로 진행할 계획입니다.
+
+교체 대상:
+- `converters.ts` → `actionbookToAST()`
+- `processResourceTags.ts` → 파서가 직접 노드 생성하므로 삭제 가능
+- `editorConverter.ts` → `parseMarkdown()` + `serializeToMarkdown()`
+- `JinjaPreview/` → `jinja/` 모듈
+
+### 마크다운 파서 간 미세한 차이
+
+기존: tiptap-markdown (markdown-it 기반) → 이 라이브러리: mdast (micromark 기반)
+
+대부분의 마크다운에서 동일한 결과를 내지만, edge case에서 차이가 발생할 수 있습니다:
+
+- **Loose/tight list 판단**: 빈 줄이 포함된 리스트의 처리 방식이 다를 수 있음
+- **리스트 들여쓰기**: 2칸 vs 4칸 인식 차이
+- **HTML 인라인**: 이 라이브러리는 HTML을 지원하지 않음 (설계 의도)
+
+**완화 방안**: 실제 프로덕션 데이터에서 추출한 마크다운 fixture를 추가하여 차이를 조기에 발견해야 합니다.
+
+### Jinja evaluator 제약
+
+안전성을 위해 재귀 하강 파서를 사용하므로, Jinja2의 전체 표현식 문법을 지원하지 않습니다.
+
+**지원됨**: `==`, `!=`, `<`, `>`, `<=`, `>=`, `and`, `or`, `not`, `in`, `is`, `is not`, 괄호, 문자열/숫자/불리언/None 리터럴, 점 표기법 변수
+
+**미지원**:
+- 필터 (`value | upper`, `items | length`)
+- 함수 호출 (`len(items)`, `range(10)`)
+- 리스트/딕셔너리 리터럴 (`[1, 2]`, `{"k": "v"}`)
+- 삼항 (`"a" if cond else "b"`)
+- `not in` 연산자
+- 슬라이싱 (`items[0]`)
+
+실제 Actionbook에서 사용 중인 조건식이 이 범위를 넘는다면 evaluator 확장이 필요합니다.
+
+### Operations 모듈은 기반만 구현
+
+- **노드 단위 편집만 가능**: 텍스트 노드 내부의 문자 레벨 편집(split/merge)은 미지원
+- **동시성 미지원**: CRDT/OT 변환 로직 없음. `NodePath` + `Transaction` 구조가 확장 포인트로 설계되어 있지만 실제 conflict resolution은 없음
+- **빈 컨테이너 허용**: 모든 listItem을 삭제한 후 빈 bulletList가 남는 등의 의미적 무결성은 검증하지 않음 (schema validation에서는 잡힘)
+
+### 번들 크기 미검증
+
+`micromark` + `mdast-util` 생태계 의존성이 추가됨. 루트 프로젝트가 이미 `remark-gfm`을 쓰고 있어 중복은 적을 것으로 예상하지만, 실제 tree-shaking 후 번들 크기 측정은 아직 하지 않았습니다.
+
+## 향후 계획
+
+### 단기 (통합 단계)
+
+1. **프로덕션 fixture 확보**: 실제 고객 Actionbook 데이터에서 마크다운 + PM JSON 쌍을 추출하여 동일성 테스트 보강
+2. **기존 코드 점진적 교체**: 가장 리스크가 낮은 읽기 전용 경로(프리뷰, 내보내기)부터 이 라이브러리로 전환
+3. **번들 크기 측정**: Vite 빌드에서의 실제 기여도 확인
+
+### 중기 (에디터 독립화)
+
+4. **actionbook-renderer**: 자체 AST를 입력으로 받는 React 읽기 전용 렌더러. 프리뷰에 먼저 적용
+5. **Jinja evaluator 확장**: 필터, `not in`, 리스트 리터럴 등 실제 사용되는 패턴 추가
+6. **서버 사이드 검증**: Node.js 서버에서 마크다운 파싱/Jinja 변수 추출 수행
+
+### 장기 (에디터 교체)
+
+7. **actionbook-editor**: 자체 AST + Operation 기반의 편집 가능한 에디터
+8. **CRDT 협업 편집**: Operation 모델 위에 Yjs/Automerge 어댑터
+9. **History 시스템**: `Transaction` + `invertOperation()` 기반 undo/redo 스택
+
+## 리스크
+
+| 리스크 | 가능성 | 영향 | 완화 |
+|--------|--------|------|------|
+| remark↔markdown-it 파싱 차이로 데이터 깨짐 | 중간 | 높음 | 프로덕션 fixture 테스트, normalize 함수, 이중 실행 비교 |
+| Jinja evaluator가 실제 사용 패턴을 커버 못함 | 낮음 | 중간 | 실사용 조건식 수집 → tokenizer/parser 확장 |
+| 번들 크기 증가 | 낮음 | 낮음 | tree-shaking 확인, lazy import 검토 |
+| `^id^` 와 기존 에디터의 caret 충돌 | 낮음 | 낮음 | 알파벳+언더스코어 제한으로 범위 축소 |

package/dist/index.d.ts

@@ -0,0 +1,393 @@
+import { B as BlockNode, a as BlockquoteNode, b as BoldMark, L as ListItemNode, c as BulletListNode, C as CodeMark, D as DocumentNode, H as HardBreakNode, I as InlineNode, d as HeadingNode, e as HorizontalRuleNode, f as ItalicMark, J as JinjaIfBranch, g as JinjaIfBlockNode, h as JinjaIfInlineNode, i as JumpPointNode, j as LinkMark, O as OrderedListNode, P as ParagraphNode, R as ResourceTagType, k as ResourceTagNode, S as StrikethroughMark, T as TableRowNode, l as TableNode, m as TableCellNode, M as Mark, n as TextNode, U as UnderlineMark, A as AstNode, N as NodePath, o as LintRule, p as LintContext, q as LintResult, r as LlmLintRule, s as LlmCompletionEndpoint, t as LintSection } from './types-rEXLrfo_.js';
+export { u as JSONContent, v as JUMP_POINT_ID_PATTERN, w as LintSeverity, x as RESOURCE_TAG_TYPES, y as fromProseMirrorJSON } from './types-rEXLrfo_.js';
+import { Root } from 'mdast';
+
+declare const bold: () => BoldMark;
+declare const italic: () => ItalicMark;
+declare const underline: () => UnderlineMark;
+declare const strikethrough: () => StrikethroughMark;
+declare const code: () => CodeMark;
+declare const link: (href: string, title?: string) => LinkMark;
+declare const text: (t: string, marks?: Mark[]) => TextNode;
+declare const resourceTag: (tagType: ResourceTagType, resourceId: string, displayText: string) => ResourceTagNode;
+declare const jumpPoint: (id: string) => JumpPointNode;
+declare const hardBreak: () => HardBreakNode;
+declare const paragraph: (...content: InlineNode[]) => ParagraphNode;
+declare const heading: (level: 1 | 2 | 3 | 4 | 5 | 6, ...content: InlineNode[]) => HeadingNode;
+declare const bulletList: (...items: ListItemNode[]) => BulletListNode;
+declare const orderedList: (start: number, ...items: ListItemNode[]) => OrderedListNode;
+declare function listItem(...content: BlockNode[]): ListItemNode;
+declare function listItem(checked: boolean | null, ...content: BlockNode[]): ListItemNode;
+declare const todoItem: (checked: boolean, ...content: BlockNode[]) => ListItemNode;
+declare const blockquote: (...content: BlockNode[]) => BlockquoteNode;
+declare const horizontalRule: () => HorizontalRuleNode;
+declare const tableCell: (header: boolean, ...content: InlineNode[]) => TableCellNode;
+declare const tableRow: (...cells: TableCellNode[]) => TableRowNode;
+declare const table: (...rows: TableRowNode[]) => TableNode;
+declare function jinjaBranch<T extends InlineNode | BlockNode>(branchType: 'if' | 'elif' | 'else', condition: string | undefined, ...content: T[]): JinjaIfBranch<T>;
+declare const jinjaIfBlock: (...branches: JinjaIfBranch<BlockNode>[]) => JinjaIfBlockNode;
+declare const jinjaIfInline: (...branches: JinjaIfBranch<InlineNode>[]) => JinjaIfInlineNode;
+declare const doc: (...content: BlockNode[]) => DocumentNode;
+
+interface VisitOptions {
+    /**
+     * Whether to compute and pass a NodePath to each callback invocation.
+     * Defaults to true for backward compatibility.
+     * Set to false for performance-critical traversals that don't need path info.
+     */
+    trackPath?: boolean;
+}
+declare function visit(node: AstNode, callback: (node: AstNode, parent?: AstNode, path?: NodePath) => void, options?: VisitOptions): void;
+declare function map(node: AstNode, fn: (node: AstNode) => AstNode, _depth?: number): AstNode;
+declare function textContent(node: AstNode, _depth?: number): string;
+declare function findAll(node: AstNode, predicate: (n: AstNode) => boolean): AstNode[];
+declare function nodeAtPath(root: DocumentNode, path: NodePath): AstNode | undefined;
+
+declare function isBlock(node: AstNode): node is BlockNode;
+declare function isInline(node: AstNode): node is InlineNode;
+declare function isTextNode(node: AstNode): node is TextNode;
+declare function isDocument(node: AstNode): node is DocumentNode;
+
+declare function parentPath(path: NodePath): NodePath;
+declare function pathToString(path: NodePath): string;
+declare function pathFromString(str: string): NodePath;
+declare function comparePaths(a: NodePath, b: NodePath): number;
+
+type ValidationError = {
+    path: string;
+    message: string;
+};
+declare function validate(doc: DocumentNode): ValidationError[];
+
+interface ParseMarkdownOptions {
+    jinjaNodes?: boolean;
+}
+declare function parseMarkdown(markdown: string, options?: ParseMarkdownOptions): DocumentNode;
+
+declare function serializeToMarkdown(doc: DocumentNode): string;
+
+/**
+ * Serialize a list of AST nodes to markdown string (for clipboard).
+ */
+declare function serializeFragment(nodes: AstNode[]): string;
+/**
+ * Parse a markdown string into a fragment (for clipboard paste).
+ * Returns block nodes by default; if the markdown is a single paragraph,
+ * returns its inline children.
+ */
+declare function parseFragment(markdown: string): InlineNode[] | BlockNode[];
+
+/**
+ * Bidirectional conversion between mdast and ActionbookAST.
+ */
+
+declare function fromMdast(root: Root): DocumentNode;
+declare function toMdast(doc: DocumentNode): Root;
+
+type ActionbookJSON = {
+    version: 3;
+    ast: DocumentNode;
+};
+declare function serializeToJSON(doc: DocumentNode): string;
+
+declare class DeserializationError extends Error {
+    readonly validationErrors?: Array<{
+        path: string;
+        message: string;
+    }> | undefined;
+    constructor(message: string, validationErrors?: Array<{
+        path: string;
+        message: string;
+    }> | undefined);
+}
+declare function deserializeFromJSON(json: string): DocumentNode;
+
+type InsertOp = {
+    readonly type: 'insert';
+    readonly path: NodePath;
+    readonly node: AstNode;
+};
+type DeleteOp = {
+    readonly type: 'delete';
+    readonly path: NodePath;
+};
+type ReplaceOp = {
+    readonly type: 'replace';
+    readonly path: NodePath;
+    readonly node: AstNode;
+};
+type Operation = InsertOp | DeleteOp | ReplaceOp;
+type Transaction = {
+    readonly operations: readonly Operation[];
+    readonly timestamp: number;
+};
+
+declare class OperationError extends Error {
+    constructor(message: string);
+}
+declare function applyOperation(doc: DocumentNode, op: Operation): DocumentNode;
+declare function applyTransaction(doc: DocumentNode, tx: Transaction): DocumentNode;
+declare function invertOperation(doc: DocumentNode, op: Operation): Operation;
+
+interface JinjaBlock {
+    type: 'if' | 'elif' | 'else' | 'endif';
+    condition?: string;
+    startIndex: number;
+    endIndex: number;
+    raw: string;
+}
+interface JinjaIfStructure {
+    id: string;
+    ifBlock: JinjaBlock;
+    elifBlocks: JinjaBlock[];
+    elseBlock?: JinjaBlock;
+    endifBlock: JinjaBlock;
+    contentRanges: Array<{
+        type: 'if' | 'elif' | 'else';
+        condition?: string;
+        startIndex: number;
+        endIndex: number;
+    }>;
+}
+interface Variable {
+    name: string;
+    type?: 'string' | 'number' | 'boolean';
+}
+interface VariableValue {
+    value: string | number | boolean;
+    type: 'string' | 'number' | 'boolean';
+}
+
+/**
+ * Pure text-based Jinja block scanner (no ProseMirror dependency).
+ */
+
+/**
+ * Scan all Jinja blocks from plain text.
+ *
+ * @param text - Plain text content
+ * @returns All Jinja blocks sorted by position
+ */
+declare function scanJinjaBlocks(text: string): JinjaBlock[];
+
+/**
+ * Structure scanned blocks into if~endif structures using stack-based approach.
+ */
+declare function structureJinjaBlocks(blocks: JinjaBlock[]): JinjaIfStructure[];
+
+interface JinjaVisualBranch {
+    type: 'if' | 'elif' | 'else';
+    condition?: string;
+    blockStartIndex: number;
+    blockEndIndex: number;
+    tagBlockIndex: number;
+}
+interface JinjaVisualStructure {
+    id: string;
+    branches: JinjaVisualBranch[];
+    ifTagBlockIndex: number;
+    endifTagBlockIndex: number;
+}
+/**
+ * Analyze a DocumentNode for Jinja if/elif/else/endif structures
+ * and map them to block-level indices.
+ */
+declare function analyzeJinjaBlocks(doc: DocumentNode): JinjaVisualStructure[];
+
+declare function extractVariables(condition: string): Variable[];
+declare function collectAllVariables(structures: JinjaIfStructure[]): Variable[];
+
+/**
+ * Safe Jinja condition evaluator using recursive descent parsing.
+ *
+ * Supports:
+ *   Comparison: ==, !=, <, >, <=, >=
+ *   Logical:    and, or, not
+ *   Identity:   is, is not
+ *   Membership: in (value in identifier)
+ *   Literals:   strings, numbers, booleans (True/False/true/false), None/null
+ *   Variables:  dot-notation identifiers (e.g. context.planName)
+ *   Grouping:   parentheses
+ *
+ * NO arbitrary code execution — only whitelisted operators and literal types.
+ */
+
+/**
+ * Safely evaluate a Jinja conditional expression.
+ *
+ * Uses a recursive-descent parser with a whitelist of allowed operators.
+ * No `eval`, `new Function`, or arbitrary code execution.
+ *
+ * @returns true/false if evaluation succeeded, null if parsing/evaluation failed
+ */
+declare function evaluateCondition(condition: string, variables: Map<string, VariableValue>): boolean | null;
+
+/**
+ * Evaluate Jinja if-block AST nodes by selecting the first truthy branch.
+ * Post-processes adjacent same-type lists to merge and renumber.
+ */
+
+/**
+ * Evaluate all jinjaIfBlock and jinjaIfInline nodes in a document,
+ * replacing them with the content of the first truthy branch.
+ */
+declare function evaluateJinjaNodes(doc: DocumentNode, variables: Map<string, VariableValue>): DocumentNode;
+
+declare function lint(doc: DocumentNode, rules: readonly LintRule[], ctx?: LintContext): LintResult[];
+
+declare const defaultRules: readonly LintRule[];
+
+interface LintAsyncOptions {
+    rules?: readonly LintRule[];
+    llmRules?: readonly LlmLintRule[];
+    llmEndpoint?: LlmCompletionEndpoint;
+    ctx?: LintContext;
+    signal?: AbortSignal;
+    onProgress?: (completed: number, total: number) => void;
+}
+/**
+ * Runs both static lint rules and LLM-based lint rules.
+ * Static rules run synchronously first, then LLM rules run per-section sequentially.
+ * Returns all results combined.
+ */
+declare function lintAsync(doc: DocumentNode, options: LintAsyncOptions): Promise<LintResult[]>;
+
+/**
+ * Splits a document into sections by heading boundaries.
+ * Each section contains the heading text, its path in the heading hierarchy,
+ * the full text content, and the block index range.
+ */
+declare function chunkByHeading(doc: DocumentNode): LintSection[];
+
+declare const defaultLlmRules: readonly LlmLintRule[];
+
+declare function extractResourceTags(doc: DocumentNode): ResourceTagNode[];
+
+declare function findDuplicateJumpPoints(doc: DocumentNode): string[];
+
+type TreeNodeType = 'section_entry' | 'jinja_condition' | 'conditional' | 'content' | 'end';
+type TreeNodeClassification = 'agent_speech' | 'tool_call_only' | 'mixed_with_speech' | 'structural' | 'internal_action' | 'user_action' | 'agent_internal';
+interface TreeNodeLine {
+    blockIndex: number;
+    content: string;
+    hasToolCall: boolean;
+    toolIds: string[];
+    hasJumpPoint: boolean;
+    jumpTargets: string[];
+    hasHandoff: boolean;
+}
+interface TreeNode {
+    id: string;
+    type: TreeNodeType;
+    blockRange: {
+        start: number;
+        end: number;
+    };
+    lines: TreeNodeLine[];
+    summary: string;
+    children: string[];
+    depth: number;
+    classification?: TreeNodeClassification;
+    conditionText?: string;
+    isJinja?: boolean;
+    branchType?: 'if' | 'elif' | 'else';
+    gotoTarget?: string;
+    hasGotoEdge?: boolean;
+    isContainer?: boolean;
+}
+interface TreeSection {
+    headingBlockIndex: number;
+    rootNodeId: string | null;
+    ancestorConditions: Array<{
+        condition: string;
+        branchType: string;
+        blockIndex: number;
+    }>;
+}
+interface GotoEdge {
+    fromNodeId: string;
+    toSection: string;
+}
+interface DecisionTree {
+    rootNodeId: string | null;
+    nodes: Record<string, TreeNode>;
+    sections: Record<string, TreeSection>;
+    gotoEdges: GotoEdge[];
+    statistics: {
+        totalNodes: number;
+        totalPaths: number;
+        maxDepth: number;
+        branchPoints: number;
+        sectionCount: number;
+    };
+}
+interface TreePath {
+    nodeIds: string[];
+    sectionSequence: string[];
+    branchDecisions: BranchDecision[];
+    contextRequirements: Record<string, string>;
+    terminationReason: 'end' | 'goto' | 'cycle' | 'leaf';
+    gotoTarget?: string;
+    cycleNodeId?: string;
+}
+interface BranchDecision {
+    nodeId: string;
+    branchType: string;
+    condition: string;
+    blockIndex: number;
+    contextRequirements?: Record<string, string>;
+}
+
+/**
+ * Tree Generator for Actionbook Decision Trees
+ *
+ * Converts an actionbook-core DocumentNode AST into a decision tree
+ * by exhaustively traversing all branches (Jinja and Conditional).
+ *
+ * Port of aidebugger's treeGenerator.js, adapted for the actionbook-core
+ * AST model (block-level nodes instead of line-level parsed objects).
+ */
+
+declare function generateDecisionTree(doc: DocumentNode): DecisionTree;
+
+declare function enumeratePaths(tree: DecisionTree, options?: {
+    startSection?: string;
+    followGotoEdges?: boolean;
+}): TreePath[];
+interface EnumeratePathsIterOptions {
+    startSection?: string;
+    followGotoEdges?: boolean;
+    /** Stop after yielding this many paths (memory guard). */
+    maxPaths?: number;
+    /** Skip paths deeper than this node count. */
+    maxDepth?: number;
+}
+/**
+ * Generator-based streaming API for path enumeration.
+ * Yields one TreePath at a time without materializing the full list.
+ * Uses an explicit stack instead of recursion to avoid call-stack overflow
+ * on deep trees.
+ */
+declare function enumeratePathsIter(tree: DecisionTree, options?: EnumeratePathsIterOptions): IterableIterator<TreePath>;
+declare function enumeratePathsBySection(tree: DecisionTree): Record<string, TreePath[]>;
+
+interface GotoEntryResolution {
+    entryNodeIds: string[];
+    targetSection: string;
+    resolved: boolean;
+}
+declare function resolveGotoEntryPath(tree: DecisionTree, sectionName: string, context: Map<string, VariableValue>): GotoEntryResolution | null;
+
+type LogicV2 = {
+    version: 2;
+    instruction: string;
+    editor_data?: string;
+};
+declare class ActionbookConversionError extends Error {
+    constructor(message: string);
+}
+declare function actionbookToAST(manual: {
+    logic: LogicV2;
+}): DocumentNode;
+
+export { ActionbookConversionError, type ActionbookJSON, AstNode, BlockNode, BlockquoteNode, BoldMark, type BranchDecision, BulletListNode, CodeMark, type DecisionTree, type DeleteOp, DeserializationError, DocumentNode, type EnumeratePathsIterOptions, type GotoEdge, type GotoEntryResolution, HardBreakNode, HeadingNode, HorizontalRuleNode, InlineNode, type InsertOp, ItalicMark, type JinjaBlock, JinjaIfBlockNode, JinjaIfBranch, JinjaIfInlineNode, type JinjaIfStructure, type JinjaVisualBranch, type JinjaVisualStructure, JumpPointNode, LinkMark, type LintAsyncOptions, LintContext, LintResult, LintRule, LintSection, ListItemNode, LlmCompletionEndpoint, LlmLintRule, Mark, NodePath, type Operation, OperationError, OrderedListNode, ParagraphNode, type ParseMarkdownOptions, type ReplaceOp, ResourceTagNode, ResourceTagType, StrikethroughMark, TableCellNode, TableNode, TableRowNode, TextNode, type Transaction, type TreeNode, type TreeNodeClassification, type TreeNodeLine, type TreeNodeType, type TreePath, type TreeSection, UnderlineMark, type ValidationError, type Variable, type VariableValue, type VisitOptions, actionbookToAST, analyzeJinjaBlocks, applyOperation, applyTransaction, blockquote, bold, bulletList, chunkByHeading, code, collectAllVariables, comparePaths, defaultLlmRules, defaultRules, deserializeFromJSON, doc, enumeratePaths, enumeratePathsBySection, enumeratePathsIter, evaluateCondition, evaluateJinjaNodes, extractResourceTags, extractVariables, findAll, findDuplicateJumpPoints, fromMdast, generateDecisionTree, hardBreak, heading, horizontalRule, invertOperation, isBlock, isDocument, isInline, isTextNode, italic, jinjaBranch, jinjaIfBlock, jinjaIfInline, jumpPoint, link, lint, lintAsync, listItem, map, nodeAtPath, orderedList, paragraph, parentPath, parseFragment, parseMarkdown, pathFromString, pathToString, resolveGotoEntryPath, resourceTag, scanJinjaBlocks, serializeFragment, serializeToJSON, serializeToMarkdown, strikethrough, structureJinjaBlocks, table, tableCell, tableRow, text, textContent, toMdast, todoItem, underline, validate, visit };