@sendbird/actionbook-core 0.10.10 → 0.10.12

package/dist/index.js

@@ -989,503 +989,8 @@ function gfmStrikethrough(options) {
   }
 }
 
-// node_modules/micromark-extension-gfm-table/lib/syntax.js
-import { markdownLineEnding as markdownLineEnding2, markdownLineEndingOrSpace as markdownLineEndingOrSpace3, markdownSpace as markdownSpace3 } from "micromark-util-character";
-
-// node_modules/micromark-extension-gfm-table/lib/edit-map.js
-var EditMap = class {
-  /**
-   * Create a new edit map.
-   */
-  constructor() {
-    this.map = [];
-  }
-  /**
-   * Create an edit: a remove and/or add at a certain place.
-   *
-   * @param {number} index
-   * @param {number} remove
-   * @param {Array<Event>} add
-   * @returns {undefined}
-   */
-  add(index, remove, add) {
-    addImplementation(this, index, remove, add);
-  }
-  // To do: add this when moving to `micromark`.
-  // /**
-  //  * Create an edit: but insert `add` before existing additions.
-  //  *
-  //  * @param {number} index
-  //  * @param {number} remove
-  //  * @param {Array<Event>} add
-  //  * @returns {undefined}
-  //  */
-  // addBefore(index, remove, add) {
-  //   addImplementation(this, index, remove, add, true)
-  // }
-  /**
-   * Done, change the events.
-   *
-   * @param {Array<Event>} events
-   * @returns {undefined}
-   */
-  consume(events) {
-    this.map.sort(function(a, b) {
-      return a[0] - b[0];
-    });
-    if (this.map.length === 0) {
-      return;
-    }
-    let index = this.map.length;
-    const vecs = [];
-    while (index > 0) {
-      index -= 1;
-      vecs.push(events.slice(this.map[index][0] + this.map[index][1]), this.map[index][2]);
-      events.length = this.map[index][0];
-    }
-    vecs.push(events.slice());
-    events.length = 0;
-    let slice = vecs.pop();
-    while (slice) {
-      for (const element of slice) {
-        events.push(element);
-      }
-      slice = vecs.pop();
-    }
-    this.map.length = 0;
-  }
-};
-function addImplementation(editMap, at, remove, add) {
-  let index = 0;
-  if (remove === 0 && add.length === 0) {
-    return;
-  }
-  while (index < editMap.map.length) {
-    if (editMap.map[index][0] === at) {
-      editMap.map[index][1] += remove;
-      editMap.map[index][2].push(...add);
-      return;
-    }
-    index += 1;
-  }
-  editMap.map.push([at, remove, add]);
-}
-
-// node_modules/micromark-extension-gfm-table/lib/infer.js
-function gfmTableAlign(events, index) {
-  let inDelimiterRow = false;
-  const align = [];
-  while (index < events.length) {
-    const event = events[index];
-    if (inDelimiterRow) {
-      if (event[0] === "enter") {
-        if (event[1].type === "tableContent") {
-          align.push(events[index + 1][1].type === "tableDelimiterMarker" ? "left" : "none");
-        }
-      } else if (event[1].type === "tableContent") {
-        if (events[index - 1][1].type === "tableDelimiterMarker") {
-          const alignIndex = align.length - 1;
-          align[alignIndex] = align[alignIndex] === "left" ? "center" : "right";
-        }
-      } else if (event[1].type === "tableDelimiterRow") {
-        break;
-      }
-    } else if (event[0] === "enter" && event[1].type === "tableDelimiterRow") {
-      inDelimiterRow = true;
-    }
-    index += 1;
-  }
-  return align;
-}
-
-// node_modules/micromark-extension-gfm-table/lib/syntax.js
-function gfmTable() {
-  return {
-    flow: {
-      null: {
-        name: "table",
-        tokenize: tokenizeTable,
-        resolveAll: resolveTable
-      }
-    }
-  };
-}
-function tokenizeTable(effects, ok2, nok) {
-  const self = this;
-  let size = 0;
-  let sizeB = 0;
-  let seen;
-  return start;
-  function start(code2) {
-    let index = self.events.length - 1;
-    while (index > -1) {
-      const type = self.events[index][1].type;
-      if (type === "lineEnding" || // Note: markdown-rs uses `whitespace` instead of `linePrefix`
-      type === "linePrefix") index--;
-      else break;
-    }
-    const tail = index > -1 ? self.events[index][1].type : null;
-    const next = tail === "tableHead" || tail === "tableRow" ? bodyRowStart : headRowBefore;
-    if (next === bodyRowStart && self.parser.lazy[self.now().line]) {
-      return nok(code2);
-    }
-    return next(code2);
-  }
-  function headRowBefore(code2) {
-    effects.enter("tableHead");
-    effects.enter("tableRow");
-    return headRowStart(code2);
-  }
-  function headRowStart(code2) {
-    if (code2 === 124) {
-      return headRowBreak(code2);
-    }
-    seen = true;
-    sizeB += 1;
-    return headRowBreak(code2);
-  }
-  function headRowBreak(code2) {
-    if (code2 === null) {
-      return nok(code2);
-    }
-    if (markdownLineEnding2(code2)) {
-      if (sizeB > 1) {
-        sizeB = 0;
-        self.interrupt = true;
-        effects.exit("tableRow");
-        effects.enter("lineEnding");
-        effects.consume(code2);
-        effects.exit("lineEnding");
-        return headDelimiterStart;
-      }
-      return nok(code2);
-    }
-    if (markdownSpace3(code2)) {
-      return factorySpace(effects, headRowBreak, "whitespace")(code2);
-    }
-    sizeB += 1;
-    if (seen) {
-      seen = false;
-      size += 1;
-    }
-    if (code2 === 124) {
-      effects.enter("tableCellDivider");
-      effects.consume(code2);
-      effects.exit("tableCellDivider");
-      seen = true;
-      return headRowBreak;
-    }
-    effects.enter("data");
-    return headRowData(code2);
-  }
-  function headRowData(code2) {
-    if (code2 === null || code2 === 124 || markdownLineEndingOrSpace3(code2)) {
-      effects.exit("data");
-      return headRowBreak(code2);
-    }
-    effects.consume(code2);
-    return code2 === 92 ? headRowEscape : headRowData;
-  }
-  function headRowEscape(code2) {
-    if (code2 === 92 || code2 === 124) {
-      effects.consume(code2);
-      return headRowData;
-    }
-    return headRowData(code2);
-  }
-  function headDelimiterStart(code2) {
-    self.interrupt = false;
-    if (self.parser.lazy[self.now().line]) {
-      return nok(code2);
-    }
-    effects.enter("tableDelimiterRow");
-    seen = false;
-    if (markdownSpace3(code2)) {
-      return factorySpace(effects, headDelimiterBefore, "linePrefix", self.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4)(code2);
-    }
-    return headDelimiterBefore(code2);
-  }
-  function headDelimiterBefore(code2) {
-    if (code2 === 45 || code2 === 58) {
-      return headDelimiterValueBefore(code2);
-    }
-    if (code2 === 124) {
-      seen = true;
-      effects.enter("tableCellDivider");
-      effects.consume(code2);
-      effects.exit("tableCellDivider");
-      return headDelimiterCellBefore;
-    }
-    return headDelimiterNok(code2);
-  }
-  function headDelimiterCellBefore(code2) {
-    if (markdownSpace3(code2)) {
-      return factorySpace(effects, headDelimiterValueBefore, "whitespace")(code2);
-    }
-    return headDelimiterValueBefore(code2);
-  }
-  function headDelimiterValueBefore(code2) {
-    if (code2 === 58) {
-      sizeB += 1;
-      seen = true;
-      effects.enter("tableDelimiterMarker");
-      effects.consume(code2);
-      effects.exit("tableDelimiterMarker");
-      return headDelimiterLeftAlignmentAfter;
-    }
-    if (code2 === 45) {
-      sizeB += 1;
-      return headDelimiterLeftAlignmentAfter(code2);
-    }
-    if (code2 === null || markdownLineEnding2(code2)) {
-      return headDelimiterCellAfter(code2);
-    }
-    return headDelimiterNok(code2);
-  }
-  function headDelimiterLeftAlignmentAfter(code2) {
-    if (code2 === 45) {
-      effects.enter("tableDelimiterFiller");
-      return headDelimiterFiller(code2);
-    }
-    return headDelimiterNok(code2);
-  }
-  function headDelimiterFiller(code2) {
-    if (code2 === 45) {
-      effects.consume(code2);
-      return headDelimiterFiller;
-    }
-    if (code2 === 58) {
-      seen = true;
-      effects.exit("tableDelimiterFiller");
-      effects.enter("tableDelimiterMarker");
-      effects.consume(code2);
-      effects.exit("tableDelimiterMarker");
-      return headDelimiterRightAlignmentAfter;
-    }
-    effects.exit("tableDelimiterFiller");
-    return headDelimiterRightAlignmentAfter(code2);
-  }
-  function headDelimiterRightAlignmentAfter(code2) {
-    if (markdownSpace3(code2)) {
-      return factorySpace(effects, headDelimiterCellAfter, "whitespace")(code2);
-    }
-    return headDelimiterCellAfter(code2);
-  }
-  function headDelimiterCellAfter(code2) {
-    if (code2 === 124) {
-      return headDelimiterBefore(code2);
-    }
-    if (code2 === null || markdownLineEnding2(code2)) {
-      if (!seen || size !== sizeB) {
-        return headDelimiterNok(code2);
-      }
-      effects.exit("tableDelimiterRow");
-      effects.exit("tableHead");
-      return ok2(code2);
-    }
-    return headDelimiterNok(code2);
-  }
-  function headDelimiterNok(code2) {
-    return nok(code2);
-  }
-  function bodyRowStart(code2) {
-    effects.enter("tableRow");
-    return bodyRowBreak(code2);
-  }
-  function bodyRowBreak(code2) {
-    if (code2 === 124) {
-      effects.enter("tableCellDivider");
-      effects.consume(code2);
-      effects.exit("tableCellDivider");
-      return bodyRowBreak;
-    }
-    if (code2 === null || markdownLineEnding2(code2)) {
-      effects.exit("tableRow");
-      return ok2(code2);
-    }
-    if (markdownSpace3(code2)) {
-      return factorySpace(effects, bodyRowBreak, "whitespace")(code2);
-    }
-    effects.enter("data");
-    return bodyRowData(code2);
-  }
-  function bodyRowData(code2) {
-    if (code2 === null || code2 === 124 || markdownLineEndingOrSpace3(code2)) {
-      effects.exit("data");
-      return bodyRowBreak(code2);
-    }
-    effects.consume(code2);
-    return code2 === 92 ? bodyRowEscape : bodyRowData;
-  }
-  function bodyRowEscape(code2) {
-    if (code2 === 92 || code2 === 124) {
-      effects.consume(code2);
-      return bodyRowData;
-    }
-    return bodyRowData(code2);
-  }
-}
-function resolveTable(events, context) {
-  let index = -1;
-  let inFirstCellAwaitingPipe = true;
-  let rowKind = 0;
-  let lastCell = [0, 0, 0, 0];
-  let cell = [0, 0, 0, 0];
-  let afterHeadAwaitingFirstBodyRow = false;
-  let lastTableEnd = 0;
-  let currentTable;
-  let currentBody;
-  let currentCell;
-  const map2 = new EditMap();
-  while (++index < events.length) {
-    const event = events[index];
-    const token = event[1];
-    if (event[0] === "enter") {
-      if (token.type === "tableHead") {
-        afterHeadAwaitingFirstBodyRow = false;
-        if (lastTableEnd !== 0) {
-          flushTableEnd(map2, context, lastTableEnd, currentTable, currentBody);
-          currentBody = void 0;
-          lastTableEnd = 0;
-        }
-        currentTable = {
-          type: "table",
-          start: Object.assign({}, token.start),
-          // Note: correct end is set later.
-          end: Object.assign({}, token.end)
-        };
-        map2.add(index, 0, [["enter", currentTable, context]]);
-      } else if (token.type === "tableRow" || token.type === "tableDelimiterRow") {
-        inFirstCellAwaitingPipe = true;
-        currentCell = void 0;
-        lastCell = [0, 0, 0, 0];
-        cell = [0, index + 1, 0, 0];
-        if (afterHeadAwaitingFirstBodyRow) {
-          afterHeadAwaitingFirstBodyRow = false;
-          currentBody = {
-            type: "tableBody",
-            start: Object.assign({}, token.start),
-            // Note: correct end is set later.
-            end: Object.assign({}, token.end)
-          };
-          map2.add(index, 0, [["enter", currentBody, context]]);
-        }
-        rowKind = token.type === "tableDelimiterRow" ? 2 : currentBody ? 3 : 1;
-      } else if (rowKind && (token.type === "data" || token.type === "tableDelimiterMarker" || token.type === "tableDelimiterFiller")) {
-        inFirstCellAwaitingPipe = false;
-        if (cell[2] === 0) {
-          if (lastCell[1] !== 0) {
-            cell[0] = cell[1];
-            currentCell = flushCell(map2, context, lastCell, rowKind, void 0, currentCell);
-            lastCell = [0, 0, 0, 0];
-          }
-          cell[2] = index;
-        }
-      } else if (token.type === "tableCellDivider") {
-        if (inFirstCellAwaitingPipe) {
-          inFirstCellAwaitingPipe = false;
-        } else {
-          if (lastCell[1] !== 0) {
-            cell[0] = cell[1];
-            currentCell = flushCell(map2, context, lastCell, rowKind, void 0, currentCell);
-          }
-          lastCell = cell;
-          cell = [lastCell[1], index, 0, 0];
-        }
-      }
-    } else if (token.type === "tableHead") {
-      afterHeadAwaitingFirstBodyRow = true;
-      lastTableEnd = index;
-    } else if (token.type === "tableRow" || token.type === "tableDelimiterRow") {
-      lastTableEnd = index;
-      if (lastCell[1] !== 0) {
-        cell[0] = cell[1];
-        currentCell = flushCell(map2, context, lastCell, rowKind, index, currentCell);
-      } else if (cell[1] !== 0) {
-        currentCell = flushCell(map2, context, cell, rowKind, index, currentCell);
-      }
-      rowKind = 0;
-    } else if (rowKind && (token.type === "data" || token.type === "tableDelimiterMarker" || token.type === "tableDelimiterFiller")) {
-      cell[3] = index;
-    }
-  }
-  if (lastTableEnd !== 0) {
-    flushTableEnd(map2, context, lastTableEnd, currentTable, currentBody);
-  }
-  map2.consume(context.events);
-  index = -1;
-  while (++index < context.events.length) {
-    const event = context.events[index];
-    if (event[0] === "enter" && event[1].type === "table") {
-      event[1]._align = gfmTableAlign(context.events, index);
-    }
-  }
-  return events;
-}
-function flushCell(map2, context, range, rowKind, rowEnd, previousCell) {
-  const groupName = rowKind === 1 ? "tableHeader" : rowKind === 2 ? "tableDelimiter" : "tableData";
-  const valueName = "tableContent";
-  if (range[0] !== 0) {
-    previousCell.end = Object.assign({}, getPoint(context.events, range[0]));
-    map2.add(range[0], 0, [["exit", previousCell, context]]);
-  }
-  const now = getPoint(context.events, range[1]);
-  previousCell = {
-    type: groupName,
-    start: Object.assign({}, now),
-    // Note: correct end is set later.
-    end: Object.assign({}, now)
-  };
-  map2.add(range[1], 0, [["enter", previousCell, context]]);
-  if (range[2] !== 0) {
-    const relatedStart = getPoint(context.events, range[2]);
-    const relatedEnd = getPoint(context.events, range[3]);
-    const valueToken = {
-      type: valueName,
-      start: Object.assign({}, relatedStart),
-      end: Object.assign({}, relatedEnd)
-    };
-    map2.add(range[2], 0, [["enter", valueToken, context]]);
-    if (rowKind !== 2) {
-      const start = context.events[range[2]];
-      const end = context.events[range[3]];
-      start[1].end = Object.assign({}, end[1].end);
-      start[1].type = "chunkText";
-      start[1].contentType = "text";
-      if (range[3] > range[2] + 1) {
-        const a = range[2] + 1;
-        const b = range[3] - range[2] - 1;
-        map2.add(a, b, []);
-      }
-    }
-    map2.add(range[3] + 1, 0, [["exit", valueToken, context]]);
-  }
-  if (rowEnd !== void 0) {
-    previousCell.end = Object.assign({}, getPoint(context.events, rowEnd));
-    map2.add(rowEnd, 0, [["exit", previousCell, context]]);
-    previousCell = void 0;
-  }
-  return previousCell;
-}
-function flushTableEnd(map2, context, index, table2, tableBody) {
-  const exits = [];
-  const related = getPoint(context.events, index);
-  if (tableBody) {
-    tableBody.end = Object.assign({}, related);
-    exits.push(["exit", tableBody, context]);
-  }
-  table2.end = Object.assign({}, related);
-  exits.push(["exit", table2, context]);
-  map2.add(index + 1, 0, exits);
-}
-function getPoint(events, index) {
-  const event = events[index];
-  const side = event[0] === "enter" ? "start" : "end";
-  return event[1][side];
-}
-
 // node_modules/micromark-extension-gfm-task-list-item/lib/syntax.js
-import { markdownLineEnding as markdownLineEnding3, markdownLineEndingOrSpace as markdownLineEndingOrSpace4, markdownSpace as markdownSpace4 } from "micromark-util-character";
+import { markdownLineEnding as markdownLineEnding2, markdownLineEndingOrSpace as markdownLineEndingOrSpace3, markdownSpace as markdownSpace3 } from "micromark-util-character";
 var tasklistCheck = {
   name: "tasklistCheck",
   tokenize: tokenizeTasklistCheck
@@ -1516,7 +1021,7 @@ function tokenizeTasklistCheck(effects, ok2, nok) {
     return inside;
   }
   function inside(code2) {
-    if (markdownLineEndingOrSpace4(code2)) {
+    if (markdownLineEndingOrSpace3(code2)) {
       effects.enter("taskListCheckValueUnchecked");
       effects.consume(code2);
       effects.exit("taskListCheckValueUnchecked");
@@ -1541,10 +1046,10 @@ function tokenizeTasklistCheck(effects, ok2, nok) {
     return nok(code2);
   }
   function after(code2) {
-    if (markdownLineEnding3(code2)) {
+    if (markdownLineEnding2(code2)) {
       return ok2(code2);
     }
-    if (markdownSpace4(code2)) {
+    if (markdownSpace3(code2)) {
       return effects.check({
         tokenize: spaceThenNonSpace
       }, ok2, nok)(code2);
@@ -1610,13 +1115,13 @@ function footnoteReferencePeek() {
 function footnoteReference(node, _, state, info) {
   const tracker = state.createTracker(info);
   let value = tracker.move("[^");
-  const exit2 = state.enter("footnoteReference");
+  const exit = state.enter("footnoteReference");
   const subexit = state.enter("reference");
   value += tracker.move(
     state.safe(state.associationId(node), { after: "]", before: value })
   );
   subexit();
-  exit2();
+  exit();
   value += tracker.move("]");
   return value;
 }
@@ -1649,7 +1154,7 @@ function gfmFootnoteToMarkdown(options) {
   function footnoteDefinition(node, _, state, info) {
     const tracker = state.createTracker(info);
     let value = tracker.move("[^");
-    const exit2 = state.enter("footnoteDefinition");
+    const exit = state.enter("footnoteDefinition");
     const subexit = state.enter("label");
     value += tracker.move(
       state.safe(state.associationId(node), { before: value, after: "]" })
@@ -1665,7 +1170,7 @@ function gfmFootnoteToMarkdown(options) {
         )
       );
     }
-    exit2();
+    exit();
     return value;
   }
 }
@@ -1713,7 +1218,7 @@ function exitStrikethrough(token) {
 }
 function handleDelete(node, _, state, info) {
   const tracker = state.createTracker(info);
-  const exit2 = state.enter("strikethrough");
+  const exit = state.enter("strikethrough");
   let value = tracker.move("~~");
   value += state.containerPhrasing(node, {
     ...tracker.current(),
@@ -1721,310 +1226,15 @@ function handleDelete(node, _, state, info) {
     after: "~"
   });
   value += tracker.move("~~");
-  exit2();
+  exit();
   return value;
 }
 function peekDelete() {
   return "~";
 }
 
-// node_modules/markdown-table/index.js
-function defaultStringLength(value) {
-  return value.length;
-}
-function markdownTable(table2, options) {
-  const settings = options || {};
-  const align = (settings.align || []).concat();
-  const stringLength = settings.stringLength || defaultStringLength;
-  const alignments = [];
-  const cellMatrix = [];
-  const sizeMatrix = [];
-  const longestCellByColumn = [];
-  let mostCellsPerRow = 0;
-  let rowIndex = -1;
-  while (++rowIndex < table2.length) {
-    const row2 = [];
-    const sizes2 = [];
-    let columnIndex2 = -1;
-    if (table2[rowIndex].length > mostCellsPerRow) {
-      mostCellsPerRow = table2[rowIndex].length;
-    }
-    while (++columnIndex2 < table2[rowIndex].length) {
-      const cell = serialize(table2[rowIndex][columnIndex2]);
-      if (settings.alignDelimiters !== false) {
-        const size = stringLength(cell);
-        sizes2[columnIndex2] = size;
-        if (longestCellByColumn[columnIndex2] === void 0 || size > longestCellByColumn[columnIndex2]) {
-          longestCellByColumn[columnIndex2] = size;
-        }
-      }
-      row2.push(cell);
-    }
-    cellMatrix[rowIndex] = row2;
-    sizeMatrix[rowIndex] = sizes2;
-  }
-  let columnIndex = -1;
-  if (typeof align === "object" && "length" in align) {
-    while (++columnIndex < mostCellsPerRow) {
-      alignments[columnIndex] = toAlignment(align[columnIndex]);
-    }
-  } else {
-    const code2 = toAlignment(align);
-    while (++columnIndex < mostCellsPerRow) {
-      alignments[columnIndex] = code2;
-    }
-  }
-  columnIndex = -1;
-  const row = [];
-  const sizes = [];
-  while (++columnIndex < mostCellsPerRow) {
-    const code2 = alignments[columnIndex];
-    let before = "";
-    let after = "";
-    if (code2 === 99) {
-      before = ":";
-      after = ":";
-    } else if (code2 === 108) {
-      before = ":";
-    } else if (code2 === 114) {
-      after = ":";
-    }
-    let size = settings.alignDelimiters === false ? 1 : Math.max(
-      1,
-      longestCellByColumn[columnIndex] - before.length - after.length
-    );
-    const cell = before + "-".repeat(size) + after;
-    if (settings.alignDelimiters !== false) {
-      size = before.length + size + after.length;
-      if (size > longestCellByColumn[columnIndex]) {
-        longestCellByColumn[columnIndex] = size;
-      }
-      sizes[columnIndex] = size;
-    }
-    row[columnIndex] = cell;
-  }
-  cellMatrix.splice(1, 0, row);
-  sizeMatrix.splice(1, 0, sizes);
-  rowIndex = -1;
-  const lines = [];
-  while (++rowIndex < cellMatrix.length) {
-    const row2 = cellMatrix[rowIndex];
-    const sizes2 = sizeMatrix[rowIndex];
-    columnIndex = -1;
-    const line = [];
-    while (++columnIndex < mostCellsPerRow) {
-      const cell = row2[columnIndex] || "";
-      let before = "";
-      let after = "";
-      if (settings.alignDelimiters !== false) {
-        const size = longestCellByColumn[columnIndex] - (sizes2[columnIndex] || 0);
-        const code2 = alignments[columnIndex];
-        if (code2 === 114) {
-          before = " ".repeat(size);
-        } else if (code2 === 99) {
-          if (size % 2) {
-            before = " ".repeat(size / 2 + 0.5);
-            after = " ".repeat(size / 2 - 0.5);
-          } else {
-            before = " ".repeat(size / 2);
-            after = before;
-          }
-        } else {
-          after = " ".repeat(size);
-        }
-      }
-      if (settings.delimiterStart !== false && !columnIndex) {
-        line.push("|");
-      }
-      if (settings.padding !== false && // Don’t add the opening space if we’re not aligning and the cell is
-      // empty: there will be a closing space.
-      !(settings.alignDelimiters === false && cell === "") && (settings.delimiterStart !== false || columnIndex)) {
-        line.push(" ");
-      }
-      if (settings.alignDelimiters !== false) {
-        line.push(before);
-      }
-      line.push(cell);
-      if (settings.alignDelimiters !== false) {
-        line.push(after);
-      }
-      if (settings.padding !== false) {
-        line.push(" ");
-      }
-      if (settings.delimiterEnd !== false || columnIndex !== mostCellsPerRow - 1) {
-        line.push("|");
-      }
-    }
-    lines.push(
-      settings.delimiterEnd === false ? line.join("").replace(/ +$/, "") : line.join("")
-    );
-  }
-  return lines.join("\n");
-}
-function serialize(value) {
-  return value === null || value === void 0 ? "" : String(value);
-}
-function toAlignment(value) {
-  const code2 = typeof value === "string" ? value.codePointAt(0) : 0;
-  return code2 === 67 || code2 === 99 ? 99 : code2 === 76 || code2 === 108 ? 108 : code2 === 82 || code2 === 114 ? 114 : 0;
-}
-
-// node_modules/mdast-util-gfm-table/lib/index.js
-import { defaultHandlers } from "mdast-util-to-markdown";
-function gfmTableFromMarkdown() {
-  return {
-    enter: {
-      table: enterTable,
-      tableData: enterCell,
-      tableHeader: enterCell,
-      tableRow: enterRow
-    },
-    exit: {
-      codeText: exitCodeText,
-      table: exitTable,
-      tableData: exit,
-      tableHeader: exit,
-      tableRow: exit
-    }
-  };
-}
-function enterTable(token) {
-  const align = token._align;
-  ok(align, "expected `_align` on table");
-  this.enter(
-    {
-      type: "table",
-      align: align.map(function(d) {
-        return d === "none" ? null : d;
-      }),
-      children: []
-    },
-    token
-  );
-  this.data.inTable = true;
-}
-function exitTable(token) {
-  this.exit(token);
-  this.data.inTable = void 0;
-}
-function enterRow(token) {
-  this.enter({ type: "tableRow", children: [] }, token);
-}
-function exit(token) {
-  this.exit(token);
-}
-function enterCell(token) {
-  this.enter({ type: "tableCell", children: [] }, token);
-}
-function exitCodeText(token) {
-  let value = this.resume();
-  if (this.data.inTable) {
-    value = value.replace(/\\([\\|])/g, replace);
-  }
-  const node = this.stack[this.stack.length - 1];
-  ok(node.type === "inlineCode");
-  node.value = value;
-  this.exit(token);
-}
-function replace($0, $1) {
-  return $1 === "|" ? $1 : $0;
-}
-function gfmTableToMarkdown(options) {
-  const settings = options || {};
-  const padding = settings.tableCellPadding;
-  const alignDelimiters = settings.tablePipeAlign;
-  const stringLength = settings.stringLength;
-  const around = padding ? " " : "|";
-  return {
-    unsafe: [
-      { character: "\r", inConstruct: "tableCell" },
-      { character: "\n", inConstruct: "tableCell" },
-      // A pipe, when followed by a tab or space (padding), or a dash or colon
-      // (unpadded delimiter row), could result in a table.
-      { atBreak: true, character: "|", after: "[	 :-]" },
-      // A pipe in a cell must be encoded.
-      { character: "|", inConstruct: "tableCell" },
-      // A colon must be followed by a dash, in which case it could start a
-      // delimiter row.
-      { atBreak: true, character: ":", after: "-" },
-      // A delimiter row can also start with a dash, when followed by more
-      // dashes, a colon, or a pipe.
-      // This is a stricter version than the built in check for lists, thematic
-      // breaks, and setex heading underlines though:
-      // <https://github.com/syntax-tree/mdast-util-to-markdown/blob/51a2038/lib/unsafe.js#L57>
-      { atBreak: true, character: "-", after: "[:|-]" }
-    ],
-    handlers: {
-      inlineCode: inlineCodeWithTable,
-      table: handleTable,
-      tableCell: handleTableCell,
-      tableRow: handleTableRow
-    }
-  };
-  function handleTable(node, _, state, info) {
-    return serializeData(handleTableAsData(node, state, info), node.align);
-  }
-  function handleTableRow(node, _, state, info) {
-    const row = handleTableRowAsData(node, state, info);
-    const value = serializeData([row]);
-    return value.slice(0, value.indexOf("\n"));
-  }
-  function handleTableCell(node, _, state, info) {
-    const exit2 = state.enter("tableCell");
-    const subexit = state.enter("phrasing");
-    const value = state.containerPhrasing(node, {
-      ...info,
-      before: around,
-      after: around
-    });
-    subexit();
-    exit2();
-    return value;
-  }
-  function serializeData(matrix, align) {
-    return markdownTable(matrix, {
-      align,
-      // @ts-expect-error: `markdown-table` types should support `null`.
-      alignDelimiters,
-      // @ts-expect-error: `markdown-table` types should support `null`.
-      padding,
-      // @ts-expect-error: `markdown-table` types should support `null`.
-      stringLength
-    });
-  }
-  function handleTableAsData(node, state, info) {
-    const children = node.children;
-    let index = -1;
-    const result = [];
-    const subexit = state.enter("table");
-    while (++index < children.length) {
-      result[index] = handleTableRowAsData(children[index], state, info);
-    }
-    subexit();
-    return result;
-  }
-  function handleTableRowAsData(node, state, info) {
-    const children = node.children;
-    let index = -1;
-    const result = [];
-    const subexit = state.enter("tableRow");
-    while (++index < children.length) {
-      result[index] = handleTableCell(children[index], node, state, info);
-    }
-    subexit();
-    return result;
-  }
-  function inlineCodeWithTable(node, parent, state) {
-    let value = defaultHandlers.inlineCode(node, parent, state);
-    if (state.stack.includes("tableCell")) {
-      value = value.replace(/\|/g, "\\$&");
-    }
-    return value;
-  }
-}
-
 // node_modules/mdast-util-gfm-task-list-item/lib/index.js
-import { defaultHandlers as defaultHandlers2 } from "mdast-util-to-markdown";
+import { defaultHandlers } from "mdast-util-to-markdown";
 function gfmTaskListItemFromMarkdown() {
   return {
     exit: {
@@ -2084,7 +1294,7 @@ function listItemWithTaskListItem(node, parent, state, info) {
   if (checkable) {
     tracker.move(checkbox);
   }
-  let value = defaultHandlers2.listItem(node, parent, state, {
+  let value = defaultHandlers.listItem(node, parent, state, {
     ...info,
     ...tracker.current()
   });
@@ -2291,18 +1501,22 @@ function convertBlock(node, depth = 0) {
     }
     case "table": {
       const tbl = node;
-      const rows = tbl.children.map((row, rowIdx) => {
-        const cells = row.children.map((cell) => {
-          const content = cell.children.flatMap((child) => convertInline(child, [], depth + 2));
-          return {
-            type: "tableCell",
-            ...rowIdx === 0 ? { header: true } : {},
-            content
-          };
-        });
-        return { type: "tableRow", content: cells };
-      });
-      return [{ type: "table", content: rows }];
+      const paragraphs = [];
+      for (const row of tbl.children) {
+        const inlines = [];
+        for (let ci = 0; ci < row.children.length; ci++) {
+          if (ci > 0 && inlines.length > 0) {
+            inlines.push({ type: "text", text: " | " });
+          }
+          for (const child of row.children[ci].children) {
+            inlines.push(...convertInline(child, [], depth + 1));
+          }
+        }
+        if (inlines.length > 0) {
+          paragraphs.push({ type: "paragraph", content: inlines });
+        }
+      }
+      return paragraphs;
     }
     default:
       if ("children" in node && Array.isArray(node.children)) {
@@ -2478,14 +1692,22 @@ function blockToMdast(node, depth = 0) {
       return result;
     }
     case "table": {
-      const rows = node.content.map((row) => ({
-        type: "tableRow",
-        children: row.content.map((cell) => ({
-          type: "tableCell",
-          children: cell.content.flatMap((c) => inlineToMdast(c, depth + 2))
-        }))
-      }));
-      return [{ type: "table", children: rows }];
+      const result = [];
+      for (const row of node.content) {
+        const children = [];
+        for (let ci = 0; ci < row.content.length; ci++) {
+          if (ci > 0 && children.length > 0) {
+            children.push({ type: "text", value: " | " });
+          }
+          for (const cell of row.content[ci].content) {
+            children.push(...inlineToMdast(cell, depth + 1));
+          }
+        }
+        if (children.length > 0) {
+          result.push({ type: "paragraph", children });
+        }
+      }
+      return result;
     }
     case "noteBlock":
       return [];
@@ -2851,11 +2073,10 @@ function jinjaBlockTransform(tree) {
 }
 
 // src/markdown/parser.ts
-var gfmNoAutolink = () => combineExtensions([gfmFootnote(), gfmStrikethrough(), gfmTable(), gfmTaskListItem()]);
+var gfmNoAutolink = () => combineExtensions([gfmFootnote(), gfmStrikethrough(), gfmTaskListItem()]);
 var gfmNoAutolinkFromMarkdown = () => [
   gfmFootnoteFromMarkdown(),
   gfmStrikethroughFromMarkdown(),
-  gfmTableFromMarkdown(),
   gfmTaskListItemFromMarkdown()
 ];
 var MAX_DEPTH4 = 128;
@@ -2923,12 +2144,11 @@ function parseMarkdown(markdown, options) {
 }
 
 // src/markdown/serializer.ts
-import { defaultHandlers as defaultHandlers3, toMarkdown } from "mdast-util-to-markdown";
+import { defaultHandlers as defaultHandlers2, toMarkdown } from "mdast-util-to-markdown";
 var gfmNoAutolinkToMarkdown = () => ({
   extensions: [
     gfmFootnoteToMarkdown(),
     gfmStrikethroughToMarkdown(),
-    gfmTableToMarkdown(),
     gfmTaskListItemToMarkdown()
   ]
 });
@@ -2946,7 +2166,7 @@ function isJinjaTagParagraph(node) {
 function textHandler(node, parent, state, info) {
   const originalUnsafe = state.unsafe;
   state.unsafe = originalUnsafe.filter((p) => !(p.character === "_" && !p.atBreak));
-  const result = defaultHandlers3.text(node, parent, state, info);
+  const result = defaultHandlers2.text(node, parent, state, info);
   state.unsafe = originalUnsafe;
   return result;
 }
@@ -2964,11 +2184,11 @@ function listItemHandler(node, parent, state, info) {
     const savedStart = list.start;
     const idx = list.children.indexOf(node);
     list.start = value - idx;
-    const result = defaultHandlers3.listItem(node, parent, state, info);
+    const result = defaultHandlers2.listItem(node, parent, state, info);
     list.start = savedStart;
     return result;
   }
-  return defaultHandlers3.listItem(node, parent, state, info);
+  return defaultHandlers2.listItem(node, parent, state, info);
 }
 function serializeToMarkdown(doc2) {
   const mdastTree = toMdast(doc2);
@@ -2995,9 +2215,9 @@ function serializeToMarkdown(doc2) {
       link: linkHandler,
       listItem: listItemHandler,
       emphasis: ((node, _parent, state, info) => {
-        const exit2 = state.enter("emphasis");
+        const exit = state.enter("emphasis");
         const value = state.containerPhrasing(node, { ...info, before: "_", after: "_" });
-        exit2();
+        exit();
         return `__${value}__`;
       }),
       ...resourceTagToMarkdown().handlers,
@@ -5797,6 +5017,428 @@ function actionbookToAST(manual) {
   }
   return EMPTY_DOC;
 }
+
+// src/graph/builder.ts
+var idCounter = 0;
+function nextId() {
+  return `vn_${++idCounter}`;
+}
+function resetIds() {
+  idCounter = 0;
+}
+function truncate(s, max = 40) {
+  const t = s.trim();
+  return t.length > max ? `${t.slice(0, max - 3)}...` : t;
+}
+function inlineSummary2(content, max = 60) {
+  const parts = [];
+  for (const node of content) {
+    if (node.type === "text") {
+      parts.push(node.text);
+    } else if (node.type === "resourceTag") {
+      parts.push(`{{${node.tagType}:${node.text}}}`);
+    } else if (node.type === "jumpPoint") {
+      parts.push(`^${node.id}^`);
+    }
+  }
+  return truncate(parts.join(""), max);
+}
+function analyzeInlines(content) {
+  const result = {
+    hasHandoff: false,
+    hasEndCall: false,
+    hasToolCall: false,
+    hasGoto: false,
+    gotoTarget: null,
+    hasJumpPoint: false,
+    jumpPointIds: [],
+    annotations: []
+  };
+  for (const node of content) {
+    if (node.type === "resourceTag") {
+      if (node.tagType === "handoff") {
+        result.hasHandoff = true;
+        result.annotations.push({ kind: "handoff", label: node.text, resourceId: node.resourceId });
+      } else if (node.tagType === "end_call" || node.resourceId === "close-happy-tiger") {
+        result.hasEndCall = true;
+        result.annotations.push({ kind: "end_call", label: node.text, resourceId: node.resourceId });
+      } else {
+        result.hasToolCall = true;
+        result.annotations.push({ kind: "tool", label: node.text, resourceId: node.resourceId });
+      }
+    } else if (node.type === "jumpPoint") {
+      result.hasJumpPoint = true;
+      result.jumpPointIds.push(node.id);
+    } else if (node.type === "text" && node.marks) {
+      for (const m of node.marks) {
+        if (m.type === "link" && m.href.startsWith("#")) {
+          result.hasGoto = true;
+          result.gotoTarget = m.href.slice(1);
+        }
+      }
+    }
+  }
+  return result;
+}
+function analyzeBlock(block) {
+  const result = {
+    hasHandoff: false,
+    hasEndCall: false,
+    hasToolCall: false,
+    hasGoto: false,
+    gotoTarget: null,
+    hasJumpPoint: false,
+    jumpPointIds: [],
+    annotations: []
+  };
+  function walk(b) {
+    if ("content" in b && Array.isArray(b.content)) {
+      for (const child of b.content) {
+        if (child.type === "text" || child.type === "resourceTag" || child.type === "jumpPoint" || child.type === "hardBreak") {
+          const a = analyzeInlines([child]);
+          merge(result, a);
+        } else {
+          walk(child);
+        }
+      }
+    }
+    if ("branches" in b && Array.isArray(b.branches)) {
+      for (const branch of b.branches) {
+        if (branch.content) {
+          for (const c of branch.content) walk(c);
+        }
+      }
+    }
+  }
+  walk(block);
+  return result;
+}
+function merge(target, source) {
+  if (source.hasHandoff) target.hasHandoff = true;
+  if (source.hasEndCall) target.hasEndCall = true;
+  if (source.hasToolCall) target.hasToolCall = true;
+  if (source.hasGoto) {
+    target.hasGoto = true;
+    target.gotoTarget = source.gotoTarget;
+  }
+  if (source.hasJumpPoint) {
+    target.hasJumpPoint = true;
+    target.jumpPointIds.push(...source.jumpPointIds);
+  }
+  target.annotations.push(...source.annotations);
+}
+function isBulletListBranching(block) {
+  if (block.type !== "bulletList") return false;
+  for (const li of block.content) {
+    if (li.content.length > 1) return true;
+    const analysis = analyzeBlock(li);
+    if (analysis.hasHandoff || analysis.hasEndCall || analysis.hasToolCall || analysis.hasGoto) return true;
+  }
+  return false;
+}
+function addEdge(ctx, from, to, type, label, branchIndex) {
+  ctx.edges.push({
+    id: `e_${ctx.edgeCounter++}`,
+    from,
+    to,
+    type,
+    label,
+    branchIndex
+  });
+}
+function processBlocks(blocks, startBlockIndex, ctx) {
+  let prevLastIds = [];
+  let firstId = null;
+  let contentAccum = null;
+  function flushContent() {
+    if (!contentAccum) return null;
+    const node = {
+      id: nextId(),
+      type: "CONTENT",
+      label: truncate(contentAccum.lines[0] || ""),
+      lines: contentAccum.lines,
+      section: ctx.currentSection,
+      annotations: contentAccum.annotations,
+      sourceBlockRange: { start: contentAccum.startIdx, end: contentAccum.endIdx },
+      gotoTarget: contentAccum.gotoTarget
+    };
+    ctx.nodes.push(node);
+    for (const jpId of contentAccum.jumpPointIds) {
+      ctx.anchorMap[jpId] = node.id;
+    }
+    const nid = node.id;
+    contentAccum = null;
+    for (const pid of prevLastIds) addEdge(ctx, pid, nid, "SEQUENTIAL");
+    if (!firstId) firstId = nid;
+    prevLastIds = [nid];
+    if (node.gotoTarget) {
+      prevLastIds = [];
+    }
+    return nid;
+  }
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    const blockIndex = startBlockIndex + i;
+    if (block.type === "blockquote" || block.type === "noteBlock" || block.type === "horizontalRule") {
+      continue;
+    }
+    if (block.type === "codeBlock") {
+      const text2 = textContent(block).trim();
+      if (text2) {
+        if (!contentAccum) {
+          contentAccum = { lines: [], annotations: [], startIdx: blockIndex, endIdx: blockIndex, jumpPointIds: [] };
+        }
+        contentAccum.lines.push(truncate(text2, 60));
+        contentAccum.endIdx = blockIndex;
+      }
+      continue;
+    }
+    if (block.type === "heading") {
+      flushContent();
+      const analysis = analyzeBlock(block);
+      ctx.currentSection = textContent(block).trim() || `Section ${blockIndex}`;
+      for (const jpId of analysis.jumpPointIds) {
+        if (!contentAccum) {
+          contentAccum = { lines: [], annotations: [], startIdx: blockIndex, endIdx: blockIndex, jumpPointIds: [] };
+        }
+        contentAccum.jumpPointIds.push(jpId);
+      }
+      continue;
+    }
+    if (block.type === "paragraph") {
+      const text2 = inlineSummary2(block.content);
+      const analysis = analyzeInlines(block.content);
+      if (analysis.hasHandoff) {
+        flushContent();
+        const node = {
+          id: nextId(),
+          type: "HANDOFF",
+          label: "Handoff",
+          lines: [text2],
+          section: ctx.currentSection,
+          annotations: analysis.annotations,
+          sourceBlockRange: { start: blockIndex, end: blockIndex }
+        };
+        ctx.nodes.push(node);
+        for (const pid of prevLastIds) addEdge(ctx, pid, node.id, "SEQUENTIAL");
+        if (!firstId) firstId = node.id;
+        prevLastIds = [node.id];
+        continue;
+      }
+      if (analysis.hasEndCall) {
+        flushContent();
+        const node = {
+          id: nextId(),
+          type: "END_CONVERSATION",
+          label: "End",
+          lines: [text2],
+          section: ctx.currentSection,
+          annotations: analysis.annotations,
+          sourceBlockRange: { start: blockIndex, end: blockIndex }
+        };
+        ctx.nodes.push(node);
+        for (const pid of prevLastIds) addEdge(ctx, pid, node.id, "SEQUENTIAL");
+        if (!firstId) firstId = node.id;
+        prevLastIds = [node.id];
+        continue;
+      }
+      if (!contentAccum) {
+        contentAccum = { lines: [], annotations: [], startIdx: blockIndex, endIdx: blockIndex, jumpPointIds: [] };
+      }
+      contentAccum.lines.push(text2);
+      contentAccum.annotations.push(...analysis.annotations);
+      contentAccum.endIdx = blockIndex;
+      contentAccum.jumpPointIds.push(...analysis.jumpPointIds);
+      if (analysis.hasGoto) contentAccum.gotoTarget = analysis.gotoTarget ?? void 0;
+      continue;
+    }
+    if (block.type === "orderedList") {
+      const items = block.content;
+      for (const li of items) {
+        const text2 = inlineSummary2(li.content[0]?.content || [], 60);
+        const analysis = analyzeBlock(li);
+        if (analysis.hasHandoff) {
+          flushContent();
+          const node = {
+            id: nextId(),
+            type: "HANDOFF",
+            label: "Handoff",
+            lines: [text2],
+            section: ctx.currentSection,
+            annotations: analysis.annotations,
+            sourceBlockRange: { start: blockIndex, end: blockIndex }
+          };
+          ctx.nodes.push(node);
+          for (const pid of prevLastIds) addEdge(ctx, pid, node.id, "SEQUENTIAL");
+          if (!firstId) firstId = node.id;
+          prevLastIds = [node.id];
+          continue;
+        }
+        if (!contentAccum) {
+          contentAccum = { lines: [], annotations: [], startIdx: blockIndex, endIdx: blockIndex, jumpPointIds: [] };
+        }
+        contentAccum.lines.push(text2);
+        contentAccum.annotations.push(...analysis.annotations);
+        contentAccum.endIdx = blockIndex;
+        contentAccum.jumpPointIds.push(...analysis.jumpPointIds);
+        if (analysis.hasGoto) contentAccum.gotoTarget = analysis.gotoTarget ?? void 0;
+      }
+      continue;
+    }
+    if (block.type === "bulletList") {
+      flushContent();
+      const items = block.content;
+      const isBranching = isBulletListBranching(block);
+      if (!isBranching) {
+        if (!contentAccum) {
+          contentAccum = { lines: [], annotations: [], startIdx: blockIndex, endIdx: blockIndex, jumpPointIds: [] };
+        }
+        for (const li of items) {
+          contentAccum.lines.push(inlineSummary2(li.content[0]?.content || []));
+        }
+        contentAccum.endIdx = blockIndex;
+        continue;
+      }
+      const branchEndIds = [];
+      const branchNodeIds = [];
+      for (let li = 0; li < items.length; li++) {
+        const item = items[li];
+        const firstBlock = item.content[0];
+        const conditionText = firstBlock && (firstBlock.type === "paragraph" || firstBlock.type === "heading") ? inlineSummary2(firstBlock.content || []) : `Branch ${li + 1}`;
+        const condNode = {
+          id: nextId(),
+          type: "BRANCH",
+          label: conditionText,
+          lines: [conditionText],
+          section: ctx.currentSection,
+          annotations: [],
+          sourceBlockRange: { start: blockIndex, end: blockIndex },
+          conditionText
+        };
+        ctx.nodes.push(condNode);
+        branchNodeIds.push(condNode.id);
+        for (const pid of prevLastIds) addEdge(ctx, pid, condNode.id, "BRANCH_TRUE", conditionText, li);
+        if (!firstId) firstId = condNode.id;
+        const subBlocks = firstBlock && (firstBlock.type === "paragraph" || firstBlock.type === "heading") ? item.content.slice(1) : item.content;
+        if (subBlocks.length > 0) {
+          const sub = processBlocks(subBlocks, blockIndex, ctx);
+          if (sub.firstId) {
+            addEdge(ctx, condNode.id, sub.firstId, "SEQUENTIAL");
+            branchEndIds.push(...sub.lastIds);
+          } else {
+            branchEndIds.push(condNode.id);
+          }
+        } else {
+          branchEndIds.push(condNode.id);
+        }
+      }
+      prevLastIds = branchEndIds;
+      continue;
+    }
+    if (block.type === "jinjaIfBlock") {
+      flushContent();
+      const branchNode = {
+        id: nextId(),
+        type: "BRANCH",
+        label: "Jinja If",
+        lines: [],
+        section: ctx.currentSection,
+        annotations: [],
+        sourceBlockRange: { start: blockIndex, end: blockIndex },
+        isJinja: true
+      };
+      ctx.nodes.push(branchNode);
+      for (const pid of prevLastIds) addEdge(ctx, pid, branchNode.id, "SEQUENTIAL");
+      if (!firstId) firstId = branchNode.id;
+      const branchEndIds = [];
+      for (let bi = 0; bi < block.branches.length; bi++) {
+        const branch = block.branches[bi];
+        const isElse = branch.branchType === "else";
+        const edgeType = isElse ? "FALLBACK" : "BRANCH_TRUE";
+        const label = isElse ? "else" : branch.condition || `Branch ${bi + 1}`;
+        const sub = processBlocks(branch.content, blockIndex, ctx);
+        if (sub.firstId) {
+          addEdge(ctx, branchNode.id, sub.firstId, edgeType, label, bi);
+          branchEndIds.push(...sub.lastIds);
+        }
+      }
+      prevLastIds = branchEndIds;
+      continue;
+    }
+  }
+  flushContent();
+  return { firstId, lastIds: prevLastIds };
+}
+function buildVizGraph(doc2) {
+  resetIds();
+  const ctx = {
+    nodes: [],
+    edges: [],
+    anchorMap: {},
+    currentSection: "_default",
+    edgeCounter: 0
+  };
+  const startNode = {
+    id: "START",
+    type: "START",
+    label: "Start",
+    lines: [],
+    section: "_default",
+    annotations: [],
+    sourceBlockRange: { start: -1, end: -1 }
+  };
+  ctx.nodes.push(startNode);
+  const result = processBlocks(doc2.content, 0, ctx);
+  if (result.firstId) {
+    addEdge(ctx, "START", result.firstId, "SEQUENTIAL");
+  }
+  for (const lastId of result.lastIds) {
+    const lastNode = ctx.nodes.find((n) => n.id === lastId);
+    if (lastNode && lastNode.type !== "HANDOFF" && lastNode.type !== "END_CONVERSATION") {
+      const endNode = {
+        id: nextId(),
+        type: "END_CONVERSATION",
+        label: "End",
+        lines: [],
+        section: lastNode.section,
+        annotations: [],
+        sourceBlockRange: { start: -1, end: -1 }
+      };
+      ctx.nodes.push(endNode);
+      addEdge(ctx, lastId, endNode.id, "SEQUENTIAL");
+    }
+  }
+  for (const node of ctx.nodes) {
+    if (!node.gotoTarget) continue;
+    const targetNodeId = ctx.anchorMap[node.gotoTarget];
+    if (targetNodeId) {
+      addEdge(ctx, node.id, targetNodeId, "GOTO", node.gotoTarget);
+    } else {
+      addEdge(ctx, node.id, node.id, "BROKEN_REF", node.gotoTarget);
+    }
+  }
+  const sectionMap = /* @__PURE__ */ new Map();
+  for (const n of ctx.nodes) {
+    if (!sectionMap.has(n.section)) sectionMap.set(n.section, []);
+    sectionMap.get(n.section).push(n.id);
+  }
+  const sections = [];
+  for (const [name, nodeIds] of sectionMap) {
+    sections.push({ name, headingBlockIndex: 0, nodeIds });
+  }
+  const nodes = ctx.nodes.map((n) => ({
+    ...n,
+    lines: n.lines,
+    annotations: n.annotations
+  }));
+  const edges = ctx.edges;
+  return {
+    nodes,
+    edges,
+    sections,
+    anchorMap: ctx.anchorMap
+  };
+}
 export {
   ActionbookConversionError,
   DeserializationError,
@@ -5810,6 +5452,7 @@ export {
   blockquote,
   bold,
   buildDocumentTree,
+  buildVizGraph,
   bulletList,
   chunkByHeading,
   code,