@bendyline/squisq 1.5.2 → 2.0.0

package/dist/chunk-5UYI3RJB.js

@@ -0,0 +1,2503 @@
+import {
+  extractPlainText,
+  findNodesByType,
+  walkMarkdownTree
+} from "./chunk-AMIR72JP.js";
+
+// src/doc/asciiDiagram/chars.ts
+var TL_CORNERS = /* @__PURE__ */ new Set(["\u250C", "\u256D", "\u250F", "\u2554"]);
+var TR_CORNERS = /* @__PURE__ */ new Set(["\u2510", "\u256E", "\u2513", "\u2557"]);
+var BL_CORNERS = /* @__PURE__ */ new Set(["\u2514", "\u2570", "\u2517", "\u255A"]);
+var BR_CORNERS = /* @__PURE__ */ new Set(["\u2518", "\u256F", "\u251B", "\u255D"]);
+var HORIZ = /* @__PURE__ */ new Set(["\u2500", "\u2501", "\u2550", "-"]);
+var VERT = /* @__PURE__ */ new Set(["\u2502", "\u2503", "\u2551", "|"]);
+var JUNCTIONS = /* @__PURE__ */ new Set([
+  "\u251C",
+  "\u2524",
+  "\u252C",
+  "\u2534",
+  "\u253C",
+  "\u2523",
+  "\u252B",
+  "\u2533",
+  "\u253B",
+  "\u254B",
+  "\u2560",
+  "\u2563",
+  "\u2566",
+  "\u2569",
+  "\u256C",
+  "\u255E",
+  "\u2561",
+  "\u2565",
+  "\u2568",
+  "\u256B",
+  "\u256A"
+]);
+var SIDE_JUNCTIONS = /* @__PURE__ */ new Set(["\u251C", "\u2524", "\u253C", "\u2523", "\u252B", "\u254B", "\u2560", "\u2563", "\u256C", "\u255E", "\u2561", "\u256B", "\u256A"]);
+var FLAT_JUNCTIONS = /* @__PURE__ */ new Set(["\u252C", "\u2534", "\u253C", "\u2533", "\u253B", "\u254B", "\u2566", "\u2569", "\u256C", "\u2565", "\u2568", "\u256B", "\u256A"]);
+var ARROW_UP = /* @__PURE__ */ new Set(["\u25B2", "\u2191"]);
+var ARROW_DOWN = /* @__PURE__ */ new Set(["\u25BC", "\u2193"]);
+var ARROW_LEFT = /* @__PURE__ */ new Set(["\u25C4", "\u2190", "\u25C0"]);
+var ARROW_RIGHT = /* @__PURE__ */ new Set(["\u25BA", "\u2192", "\u25B6"]);
+function isTlCorner(ch) {
+  return TL_CORNERS.has(ch);
+}
+function isTrCorner(ch) {
+  return TR_CORNERS.has(ch);
+}
+function isBlCorner(ch) {
+  return BL_CORNERS.has(ch);
+}
+function isBrCorner(ch) {
+  return BR_CORNERS.has(ch);
+}
+function isAnyCorner(ch) {
+  return TL_CORNERS.has(ch) || TR_CORNERS.has(ch) || BL_CORNERS.has(ch) || BR_CORNERS.has(ch);
+}
+function isHoriz(ch) {
+  return HORIZ.has(ch);
+}
+function isVert(ch) {
+  return VERT.has(ch);
+}
+function isJunction(ch) {
+  return JUNCTIONS.has(ch);
+}
+function isPlus(ch) {
+  return ch === "+";
+}
+function isFlatBorderChar(ch) {
+  return isHoriz(ch) || FLAT_JUNCTIONS.has(ch) || isPlus(ch);
+}
+function isSideBorderChar(ch) {
+  return isVert(ch) || SIDE_JUNCTIONS.has(ch) || isPlus(ch);
+}
+function arrowDirection(ch) {
+  if (ARROW_UP.has(ch)) return "up";
+  if (ARROW_DOWN.has(ch)) return "down";
+  if (ARROW_LEFT.has(ch)) return "left";
+  if (ARROW_RIGHT.has(ch)) return "right";
+  return null;
+}
+function asciiArrowDirection(ch) {
+  if (ch === "^") return "up";
+  if (ch === "v" || ch === "V") return "down";
+  if (ch === "<") return "left";
+  if (ch === ">") return "right";
+  return null;
+}
+function isLineChar(ch) {
+  return isHoriz(ch) || isVert(ch) || isJunction(ch) || isPlus(ch) || isAnyCorner(ch);
+}
+function isUnicodeStructural(ch) {
+  const code = ch.codePointAt(0) ?? 0;
+  return code >= 9472 && code <= 9599 || ARROW_UP.has(ch) || ARROW_DOWN.has(ch) || ch === "\u2190" || ch === "\u2192" || ch === "\u25C4" || ch === "\u25BA" || ch === "\u25C0" || ch === "\u25B6";
+}
+function isAsciiStructural(ch) {
+  return ch === "+" || ch === "-" || ch === "|";
+}
+var UNICODE_VOCAB = {
+  tl: "\u250C",
+  tr: "\u2510",
+  bl: "\u2514",
+  br: "\u2518",
+  h: "\u2500",
+  v: "\u2502",
+  stemDown: "\u252C",
+  stemUp: "\u2534",
+  stemLeft: "\u2524",
+  stemRight: "\u251C",
+  cross: "\u253C",
+  arrowUp: "\u25B2",
+  arrowDown: "\u25BC",
+  arrowLeft: "\u25C4",
+  arrowRight: "\u25BA",
+  // Named by the pair of open sides: e.g. turnDownRight opens downward and
+  // to the right (a line coming from below turning to the right) = '┌'.
+  turnDownRight: "\u250C",
+  turnDownLeft: "\u2510",
+  turnUpRight: "\u2514",
+  turnUpLeft: "\u2518"
+};
+var ASCII_VOCAB = {
+  tl: "+",
+  tr: "+",
+  bl: "+",
+  br: "+",
+  h: "-",
+  v: "|",
+  stemDown: "+",
+  stemUp: "+",
+  stemLeft: "+",
+  stemRight: "+",
+  cross: "+",
+  arrowUp: "^",
+  arrowDown: "v",
+  arrowLeft: "<",
+  arrowRight: ">",
+  turnDownRight: "+",
+  turnDownLeft: "+",
+  turnUpRight: "+",
+  turnUpLeft: "+"
+};
+
+// src/doc/asciiDiagram/parse.ts
+var MAX_TITLE_RUN = 60;
+var MAX_BRIDGE_GAP = 40;
+var MAX_LOOSE_WARNINGS = 10;
+var MAX_WALL_GAP = 3;
+var REPAIR_WALL_GAP = 10;
+var CROSS_CHARS = /* @__PURE__ */ new Set(["\u253C", "\u254B", "\u256C", "\u256B", "\u256A"]);
+function parseAsciiDiagram(text) {
+  return parseAsciiDiagramWithStats(text).diagram;
+}
+function parseAsciiDiagramWithStats(text) {
+  const warnings = [];
+  const grid = buildGrid(text, warnings);
+  const H = grid.length;
+  const W = H > 0 ? grid[0].length : 0;
+  let totalNonSpaceCells = 0;
+  let hasWideChars = false;
+  for (let r = 0; r < H; r++) {
+    for (let c = 0; c < W; c++) {
+      const ch = grid[r][c];
+      if (ch !== " ") totalNonSpaceCells++;
+      if (!hasWideChars && isWideChar(ch)) hasWideChars = true;
+    }
+  }
+  if (hasWideChars) warnings.push("wide-chars");
+  const style = detectStyle(grid);
+  const rects = traceBoxes(grid);
+  const boxes = buildBoxes(grid, rects, warnings);
+  const mask = new Uint8Array(W * H);
+  const perimeterOwners = /* @__PURE__ */ new Map();
+  for (let b = 0; b < boxes.length; b++) {
+    const box = boxes[b];
+    for (let c = box.c0; c <= box.c1; c++) {
+      for (const r of [box.r0, box.r1]) {
+        mask[r * W + c] = 1;
+        const owners = perimeterOwners.get(r * W + c) ?? [];
+        owners.push(b);
+        perimeterOwners.set(r * W + c, owners);
+      }
+    }
+    for (let r = box.r0 + 1; r <= box.r1 - 1; r++) {
+      for (const c of [box.c0, box.c1]) {
+        mask[r * W + c] = 1;
+        const owners = perimeterOwners.get(r * W + c) ?? [];
+        owners.push(b);
+        perimeterOwners.set(r * W + c, owners);
+      }
+    }
+  }
+  const isContainer = boxes.map((_, i) => boxes.some((b) => b.parentIdx === i));
+  for (let b = 0; b < boxes.length; b++) {
+    const box = boxes[b];
+    if (!isContainer[b]) {
+      for (let r = box.r0 + 1; r <= box.r1 - 1; r++) {
+        for (let c = box.c0 + 1; c <= box.c1 - 1; c++) mask[r * W + c] = 1;
+      }
+    } else {
+      const minChildR0 = Math.min(
+        ...boxes.filter((child) => child.parentIdx === b).map((child) => child.r0)
+      );
+      for (let r = box.r0 + 1; r < minChildR0; r++) {
+        for (let c = box.c0 + 1; c <= box.c1 - 1; c++) {
+          const ch = grid[r][c];
+          if (ch !== " " && !isLineChar(ch) && arrowDirection(ch) === null) mask[r * W + c] = 1;
+        }
+      }
+    }
+  }
+  const { edges, edgeCells } = extractEdges(grid, mask, perimeterOwners, boxes, warnings);
+  let looseNonSpaceCells = 0;
+  const looseRuns = [];
+  for (let r = 0; r < H; r++) {
+    let run = "";
+    const flush = () => {
+      if (run.trim().length > 0) looseRuns.push(`@${r}: ${truncate(run.trim(), 30)}`);
+      run = "";
+    };
+    const isLooseCell = (c) => {
+      if (c < 0 || c >= W) return false;
+      const idx = r * W + c;
+      return grid[r][c] !== " " && !mask[idx] && !edgeCells.has(idx);
+    };
+    for (let c = 0; c < W; c++) {
+      if (isLooseCell(c)) {
+        run += grid[r][c];
+        looseNonSpaceCells++;
+      } else if (run !== "" && grid[r][c] === " " && isLooseCell(c + 1)) {
+        run += " ";
+      } else {
+        flush();
+      }
+    }
+    flush();
+  }
+  for (const runText of looseRuns.slice(0, MAX_LOOSE_WARNINGS)) {
+    warnings.push(`loose-text ${runText}`);
+  }
+  if (looseRuns.length > MAX_LOOSE_WARNINGS) {
+    warnings.push(`loose-text (+${looseRuns.length - MAX_LOOSE_WARNINGS} more)`);
+  }
+  const nodes = boxes.map((box) => ({
+    id: box.id,
+    label: box.labelLines.join("\n"),
+    col: box.c0,
+    row: box.r0,
+    wCols: box.c1 - box.c0 + 1,
+    hRows: box.r1 - box.r0 + 1,
+    ...box.parentIdx >= 0 ? { containerId: boxes[box.parentIdx].id } : {}
+  }));
+  return {
+    diagram: { nodes, edges, style, warnings },
+    stats: { totalNonSpaceCells, looseNonSpaceCells, hasWideChars }
+  };
+}
+function buildGrid(text, warnings) {
+  const rawLines = text.replace(/\r\n?/g, "\n").split("\n");
+  let hadTab = false;
+  const rows = rawLines.map((line) => {
+    const cells = [];
+    for (const ch of line) {
+      if (ch === "	") {
+        hadTab = true;
+        do {
+          cells.push(" ");
+        } while (cells.length % 4 !== 0);
+      } else {
+        cells.push(ch);
+      }
+    }
+    return cells;
+  });
+  if (hadTab) warnings.push("tabs-expanded");
+  let width = 0;
+  for (const row of rows) width = Math.max(width, row.length);
+  for (const row of rows) {
+    while (row.length < width) row.push(" ");
+  }
+  return rows;
+}
+function isWideChar(ch) {
+  const c = ch.codePointAt(0) ?? 0;
+  return c >= 4352 && c <= 4447 || c >= 11904 && c <= 12350 || c >= 12353 && c <= 13311 || c >= 13312 && c <= 19903 || c >= 19968 && c <= 40959 || c >= 44032 && c <= 55203 || c >= 63744 && c <= 64255 || c >= 65072 && c <= 65103 || c >= 65280 && c <= 65376 || c >= 127744 && c <= 129791;
+}
+function detectStyle(grid) {
+  let unicode = 0;
+  let ascii = 0;
+  for (const row of grid) {
+    for (const ch of row) {
+      if (isUnicodeStructural(ch)) unicode++;
+      else if (isAsciiStructural(ch)) ascii++;
+    }
+  }
+  return ascii > unicode ? "ascii" : "unicode";
+}
+function traceBoxes(grid, repair = false) {
+  const H = grid.length;
+  const W = H > 0 ? grid[0].length : 0;
+  const found = [];
+  for (let r = 0; r < H; r++) {
+    for (let c = 0; c < W; c++) {
+      if (!isTlCandidate(grid, r, c)) continue;
+      const rect = traceBoxFrom(grid, r, c, repair);
+      if (rect) found.push(rect);
+    }
+  }
+  return found;
+}
+function toGrid(text) {
+  return buildGrid(text, []);
+}
+function isTlCandidate(grid, r, c) {
+  const ch = grid[r][c];
+  if (isTlCorner(ch)) return true;
+  if (!isPlus(ch) && !isJunction(ch)) return false;
+  const right = grid[r][c + 1] ?? " ";
+  const below = grid[r + 1]?.[c] ?? " ";
+  const rightOk = isFlatBorderChar(right) || isTrCorner(right);
+  const belowOk = isSideBorderChar(below) || isBlCorner(below);
+  return rightOk && belowOk;
+}
+function traceBoxFrom(grid, r0, c0, repair = false) {
+  const H = grid.length;
+  const W = grid[0]?.length ?? 0;
+  const trCandidates = [];
+  let titleRun = null;
+  let c = c0 + 1;
+  while (c < W) {
+    const ch = grid[r0][c];
+    if (isTrCorner(ch)) {
+      trCandidates.push(c);
+      break;
+    }
+    if (isPlus(ch) || isJunction(ch)) {
+      trCandidates.push(c);
+      c++;
+      continue;
+    }
+    if (isFlatBorderChar(ch)) {
+      c++;
+      continue;
+    }
+    if (arrowDirection(ch) !== null) {
+      c++;
+      continue;
+    }
+    if (titleRun) break;
+    let end = c;
+    let sawText = false;
+    while (end < W && end - c <= MAX_TITLE_RUN) {
+      const tch = grid[r0][end];
+      if (isFlatBorderChar(tch) || isTrCorner(tch) || arrowDirection(tch) !== null) break;
+      if (tch !== " ") sawText = true;
+      end++;
+    }
+    if (end >= W || end - c > MAX_TITLE_RUN || !sawText || end === c) break;
+    titleRun = { from: c, to: end - 1 };
+    c = end;
+  }
+  if (trCandidates.length === 0) return null;
+  const leftCandidates = walkSideWall(grid, c0, r0, H, isBlCorner, repair);
+  if (leftCandidates.length === 0) return null;
+  const leftSet = new Set(leftCandidates);
+  for (const c1 of trCandidates) {
+    if (c1 < c0 + 2) continue;
+    const rightCandidates = walkSideWall(grid, c1, r0, H, isBrCorner, repair);
+    for (const r1 of rightCandidates) {
+      if (r1 < r0 + 2) continue;
+      if (!leftSet.has(r1)) continue;
+      let ok = true;
+      for (let bc = c0 + 1; bc <= c1 - 1; bc++) {
+        if (!isFlatBorderChar(grid[r1][bc])) {
+          ok = false;
+          break;
+        }
+      }
+      if (!ok) continue;
+      const win = repair ? 1 : 0;
+      let leftBorders = 0;
+      let rightBorders = 0;
+      for (let ir = r0 + 1; ir <= r1 - 1; ir++) {
+        if (hasSideBorderNear(grid[ir], c0, win)) leftBorders++;
+        if (hasSideBorderNear(grid[ir], c1, win)) rightBorders++;
+      }
+      if (leftBorders === 0 || rightBorders === 0) continue;
+      const title = titleRun && titleRun.to < c1 ? grid[r0].slice(titleRun.from, titleRun.to + 1).join("").trim() : void 0;
+      return { r0, c0, r1, c1, ...title ? { borderTitle: title } : {} };
+    }
+  }
+  return null;
+}
+function hasSideBorderNear(row, col, win) {
+  for (let c = col - win; c <= col + win; c++) {
+    const ch = row[c];
+    if (ch !== void 0 && isSideBorderChar(ch)) return true;
+  }
+  return false;
+}
+function walkSideWall(grid, col, r0, H, isCorner, repair = false) {
+  const candidates = [];
+  const maxGap = repair ? REPAIR_WALL_GAP : MAX_WALL_GAP;
+  let gap = 0;
+  for (let r = r0 + 1; r < H; r++) {
+    const ch = grid[r][col];
+    if (isCorner(ch)) {
+      candidates.push(r);
+      break;
+    }
+    if (isPlus(ch) || isJunction(ch)) {
+      candidates.push(r);
+      gap = 0;
+      continue;
+    }
+    if (isSideBorderChar(ch)) {
+      gap = 0;
+      continue;
+    }
+    if (!repair && (isLineChar(ch) || arrowDirection(ch) !== null)) break;
+    if (++gap > maxGap) break;
+  }
+  return candidates;
+}
+function strictlyContains(parent, child) {
+  return parent.r0 < child.r0 && parent.c0 < child.c0 && parent.r1 > child.r1 && parent.c1 > child.c1;
+}
+function interiorsOverlap(a, b) {
+  return a.r0 + 1 <= b.r1 - 1 && b.r0 + 1 <= a.r1 - 1 && a.c0 + 1 <= b.c1 - 1 && b.c0 + 1 <= a.c1 - 1;
+}
+function area(rect) {
+  return (rect.r1 - rect.r0 + 1) * (rect.c1 - rect.c0 + 1);
+}
+function buildBoxes(grid, rects, warnings) {
+  const sorted = [...rects].sort((a, b) => a.r0 - b.r0 || a.c0 - b.c0);
+  const parentIdx = sorted.map((child, i) => {
+    let best = -1;
+    let bestArea = Infinity;
+    for (let j = 0; j < sorted.length; j++) {
+      if (j === i) continue;
+      if (!strictlyContains(sorted[j], child)) continue;
+      const a = area(sorted[j]);
+      if (a < bestArea) {
+        bestArea = a;
+        best = j;
+      }
+    }
+    return best;
+  });
+  let warnedOverlap = false;
+  for (let i = 0; i < sorted.length && !warnedOverlap; i++) {
+    for (let j = i + 1; j < sorted.length; j++) {
+      if (interiorsOverlap(sorted[i], sorted[j]) && !strictlyContains(sorted[i], sorted[j]) && !strictlyContains(sorted[j], sorted[i])) {
+        warnings.push("overlapping-boxes");
+        warnedOverlap = true;
+        break;
+      }
+    }
+  }
+  const hasChildren = sorted.map((_, i) => parentIdx.includes(i));
+  const usedIds = /* @__PURE__ */ new Map();
+  const boxes = sorted.map((rect, i) => {
+    const labelLines = [];
+    if (rect.borderTitle) labelLines.push(rect.borderTitle);
+    if (!hasChildren[i]) {
+      for (let r = rect.r0 + 1; r <= rect.r1 - 1; r++) {
+        const rowText = grid[r].slice(rect.c0 + 1, rect.c1).join("");
+        if (isDividerRow(rowText)) continue;
+        const trimmed = rowText.trim();
+        if (trimmed.length > 0) labelLines.push(trimmed);
+      }
+    } else {
+      const minChildR0 = Math.min(
+        ...sorted.filter((_, j) => parentIdx[j] === i).map((child) => child.r0)
+      );
+      for (let r = rect.r0 + 1; r < minChildR0; r++) {
+        const rowText = grid[r].slice(rect.c0 + 1, rect.c1).map((ch) => isLineChar(ch) || arrowDirection(ch) !== null ? " " : ch).join("").trim();
+        if (rowText.length > 0) labelLines.push(rowText);
+      }
+    }
+    const base = slugify(labelLines[0] ?? "");
+    const count = usedIds.get(base) ?? 0;
+    usedIds.set(base, count + 1);
+    const id = count === 0 ? base : `${base}-${count + 1}`;
+    return { ...rect, parentIdx: parentIdx[i], labelLines, id };
+  });
+  return boxes;
+}
+function isDividerRow(rowText) {
+  let sawLine = false;
+  for (const ch of rowText) {
+    if (ch === " ") continue;
+    if (isHoriz(ch) || isJunction(ch) || isPlus(ch)) {
+      sawLine = true;
+      continue;
+    }
+    return false;
+  }
+  return sawLine;
+}
+function slugify(s) {
+  const slug2 = s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug2 || "node";
+}
+function extractEdges(grid, mask, perimeterOwners, boxes, warnings) {
+  const H = grid.length;
+  const W = H > 0 ? grid[0].length : 0;
+  const cells = /* @__PURE__ */ new Map();
+  for (let r = 0; r < H; r++) {
+    for (let c = 0; c < W; c++) {
+      const idx = r * W + c;
+      if (mask[idx]) continue;
+      const ch = grid[r][c];
+      const uni = arrowDirection(ch);
+      if (uni) {
+        cells.set(idx, { arrow: uni });
+        continue;
+      }
+      const asc = asciiArrowDirection(ch);
+      if (asc && asciiArrowGate(grid, r, c, asc)) {
+        cells.set(idx, { arrow: asc });
+        continue;
+      }
+      if (isLineChar(ch)) cells.set(idx, { arrow: null });
+    }
+  }
+  for (let r = 0; r < H; r++) {
+    let c = 0;
+    while (c < W) {
+      const idx = r * W + c;
+      if (!cells.has(idx) || !isHoriz(grid[r][c])) {
+        c++;
+        continue;
+      }
+      let runEnd = c;
+      while (runEnd + 1 < W && cells.has(r * W + runEnd + 1) && isHoriz(grid[r][runEnd + 1])) {
+        runEnd++;
+      }
+      let g = runEnd + 1;
+      let sawText = false;
+      let failed = false;
+      while (g < W && g - runEnd - 1 <= MAX_BRIDGE_GAP) {
+        const gch = grid[r][g];
+        const gidx = r * W + g;
+        if (mask[gidx] || isVert(gch)) {
+          failed = true;
+          break;
+        }
+        if (isHoriz(gch)) break;
+        if (isLineChar(gch) || arrowDirection(gch) !== null) {
+          failed = true;
+          break;
+        }
+        const asc = asciiArrowDirection(gch);
+        if (asc && asciiArrowGate(grid, r, g, asc)) {
+          failed = true;
+          break;
+        }
+        if (gch !== " ") sawText = true;
+        g++;
+      }
+      if (!failed && g < W && g > runEnd + 1 && sawText && isHoriz(grid[r][g]) && !mask[r * W + g]) {
+        const label = grid[r].slice(runEnd + 1, g).join("").trim();
+        for (let bc = runEnd + 1; bc < g; bc++) {
+          cells.set(r * W + bc, { arrow: null, bridgeLabel: label });
+        }
+        c = g;
+      } else {
+        c = runEnd + 1;
+      }
+    }
+  }
+  const isCrossCell = (idx) => CROSS_CHARS.has(grid[Math.floor(idx / W)][idx % W]);
+  const stateKey = (idx, channel) => idx * 2 + channel;
+  const visited = /* @__PURE__ */ new Set();
+  const components = [];
+  const seeds = [];
+  for (const idx of cells.keys()) {
+    seeds.push([idx, 0]);
+    if (isCrossCell(idx)) seeds.push([idx, 1]);
+  }
+  for (const [seedIdx, seedChannel] of seeds) {
+    if (visited.has(stateKey(seedIdx, seedChannel))) continue;
+    const componentCells = /* @__PURE__ */ new Set();
+    const queue = [[seedIdx, seedChannel]];
+    visited.add(stateKey(seedIdx, seedChannel));
+    while (queue.length > 0) {
+      const [idx, channel] = queue.pop();
+      componentCells.add(idx);
+      const r = Math.floor(idx / W);
+      const c = idx % W;
+      const neighbors = isCrossCell(idx) && channel === 1 ? [
+        [r - 1, c],
+        [r + 1, c]
+      ] : isCrossCell(idx) ? [
+        [r, c - 1],
+        [r, c + 1]
+      ] : [
+        [r - 1, c],
+        [r + 1, c],
+        [r, c - 1],
+        [r, c + 1]
+      ];
+      for (const [nr, nc] of neighbors) {
+        if (nr < 0 || nr >= H || nc < 0 || nc >= W) continue;
+        const nidx = nr * W + nc;
+        if (!cells.has(nidx)) continue;
+        const nChannel = isCrossCell(nidx) ? nr !== r ? 1 : 0 : 0;
+        const key = stateKey(nidx, nChannel);
+        if (!visited.has(key)) {
+          visited.add(key);
+          queue.push([nidx, nChannel]);
+        }
+      }
+    }
+    components.push([...componentCells].sort((a, b) => a - b));
+  }
+  components.sort((a, b) => a[0] - b[0]);
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  let mergedParallel = false;
+  const looseComponents = /* @__PURE__ */ new Set();
+  const sideLabelCells = /* @__PURE__ */ new Set();
+  for (const component of components) {
+    const inComponent = new Set(component);
+    const endpoints = [];
+    for (const idx of component) {
+      const r = Math.floor(idx / W);
+      const c = idx % W;
+      let neighbors = 0;
+      for (const [nr, nc] of [
+        [r - 1, c],
+        [r + 1, c],
+        [r, c - 1],
+        [r, c + 1]
+      ]) {
+        if (inComponent.has(nr * W + nc)) neighbors++;
+      }
+      const info = cells.get(idx);
+      if (neighbors <= 1 || info.arrow !== null) endpoints.push(idx);
+    }
+    const attachmentsByBox = /* @__PURE__ */ new Map();
+    let dangling = false;
+    for (const idx of endpoints) {
+      const r = Math.floor(idx / W);
+      const c = idx % W;
+      const info = cells.get(idx);
+      const boxIdx = snapEndpoint(r, c, info.arrow, perimeterOwners, boxes, W, H);
+      if (boxIdx === null) {
+        dangling = true;
+        continue;
+      }
+      const existing = attachmentsByBox.get(boxIdx);
+      if (existing) {
+        existing.isArrowEnd = existing.isArrowEnd || info.arrow !== null;
+      } else {
+        attachmentsByBox.set(boxIdx, { boxIdx, isArrowEnd: info.arrow !== null });
+      }
+    }
+    const nearestOwner = (r, c) => {
+      const owners = perimeterOwners.get(r * W + c) ?? [];
+      if (owners.length === 0) return null;
+      return [...owners].sort(
+        (a, b) => boxes[a].r0 - boxes[b].r0 || boxes[a].c0 - boxes[b].c0 || a - b
+      )[0];
+    };
+    for (const idx of component) {
+      const r = Math.floor(idx / W);
+      const c = idx % W;
+      const ch = grid[r][c];
+      if (!isJunction(ch) && !isPlus(ch)) continue;
+      for (const [dr, dc] of [
+        [-1, 0],
+        [1, 0],
+        [0, -1],
+        [0, 1]
+      ]) {
+        const boxIdx = nearestOwner(r + dr, c + dc);
+        if (boxIdx !== null && !attachmentsByBox.has(boxIdx)) {
+          attachmentsByBox.set(boxIdx, { boxIdx, isArrowEnd: false });
+        }
+      }
+    }
+    for (const idx of component) {
+      const r = Math.floor(idx / W);
+      const c = idx % W;
+      const info = cells.get(idx);
+      if (info.arrow === null) continue;
+      const [dr, dc] = info.arrow === "down" ? [-1, 0] : info.arrow === "up" ? [1, 0] : info.arrow === "right" ? [0, -1] : [0, 1];
+      const boxIdx = nearestOwner(r + dr, c + dc);
+      if (boxIdx !== null && !attachmentsByBox.has(boxIdx)) {
+        attachmentsByBox.set(boxIdx, { boxIdx, isArrowEnd: false });
+      }
+    }
+    const attachments = [...attachmentsByBox.values()].sort(
+      (a, b) => boxes[a.boxIdx].r0 - boxes[b.boxIdx].r0 || boxes[a.boxIdx].c0 - boxes[b.boxIdx].c0
+    );
+    if (attachments.length === 0) {
+      for (const idx of component) looseComponents.add(idx);
+      warnings.push("dangling-edge");
+      continue;
+    }
+    if (attachments.length === 1) {
+      warnings.push("dangling-edge");
+      continue;
+    }
+    if (dangling) warnings.push("dangling-edge");
+    const bridgeLabels = [];
+    for (const idx of component) {
+      const info = cells.get(idx);
+      if (info.bridgeLabel && !bridgeLabels.includes(info.bridgeLabel)) {
+        bridgeLabels.push(info.bridgeLabel);
+      }
+    }
+    const isLabelStop = (ch) => isLineChar(ch) && ch !== "-" || arrowDirection(ch) !== null;
+    const hasAlnum = (s) => /[a-z0-9]/i.test(s);
+    let label = bridgeLabels[0];
+    if (!label) {
+      outer: for (const idx of component) {
+        const r = Math.floor(idx / W);
+        const c = idx % W;
+        if (!isVert(grid[r][c])) continue;
+        if ((grid[r][c + 1] ?? "") === " ") {
+          let end = c + 2;
+          let run = "";
+          while (end < W) {
+            const ch = grid[r][end];
+            if (mask[r * W + end] || isLabelStop(ch)) break;
+            if (ch === " " && (grid[r][end + 1] ?? " ") === " ") break;
+            run += ch;
+            end++;
+          }
+          const clean = run.trim().replace(/^-+|-+$/g, "");
+          if (clean.length > 0 && clean.length <= MAX_BRIDGE_GAP && hasAlnum(clean)) {
+            label = clean;
+            for (let lc = c + 2; lc < end; lc++) sideLabelCells.add(r * W + lc);
+            break outer;
+          }
+        }
+        if ((grid[r][c - 1] ?? "") === " ") {
+          let start = c - 2;
+          let run = "";
+          while (start >= 0) {
+            const ch = grid[r][start];
+            if (mask[r * W + start] || isLabelStop(ch)) break;
+            if (ch === " " && (grid[r][start - 1] ?? " ") === " ") break;
+            run = ch + run;
+            start--;
+          }
+          const clean = run.trim().replace(/^-+|-+$/g, "");
+          if (clean.length > 0 && clean.length <= MAX_BRIDGE_GAP && hasAlnum(clean)) {
+            label = clean;
+            for (let lc = start + 1; lc <= c - 2; lc++) sideLabelCells.add(r * W + lc);
+            break outer;
+          }
+        }
+      }
+    }
+    if (bridgeLabels.length > 1) warnings.push("multiple-edge-labels");
+    const pushEdge = (sourceIdx, targetIdx, directed) => {
+      const edge = {
+        source: boxes[sourceIdx].id,
+        target: boxes[targetIdx].id,
+        ...label ? { label } : {},
+        directed
+      };
+      const key = `${edge.source}|${edge.target}|${edge.directed}|${edge.label ?? ""}`;
+      if (seen.has(key)) {
+        mergedParallel = true;
+        return;
+      }
+      seen.add(key);
+      edges.push(edge);
+    };
+    const arrowEnds = attachments.filter((a) => a.isArrowEnd);
+    const plainEnds = attachments.filter((a) => !a.isArrowEnd);
+    if (attachments.length === 2) {
+      const [a, b] = attachments;
+      if (arrowEnds.length === 2) {
+        pushEdge(a.boxIdx, b.boxIdx, true);
+        pushEdge(b.boxIdx, a.boxIdx, true);
+      } else if (arrowEnds.length === 1) {
+        const target = arrowEnds[0];
+        const source = a === target ? b : a;
+        pushEdge(source.boxIdx, target.boxIdx, true);
+      } else {
+        pushEdge(a.boxIdx, b.boxIdx, false);
+      }
+    } else if (plainEnds.length === 1 && arrowEnds.length >= 1) {
+      for (const target of arrowEnds) pushEdge(plainEnds[0].boxIdx, target.boxIdx, true);
+    } else if (arrowEnds.length === 1 && plainEnds.length >= 1) {
+      for (const source of plainEnds) pushEdge(source.boxIdx, arrowEnds[0].boxIdx, true);
+    } else if (arrowEnds.length === 0) {
+      warnings.push("ambiguous-bus");
+      for (let i = 1; i < attachments.length; i++) {
+        pushEdge(attachments[0].boxIdx, attachments[i].boxIdx, false);
+      }
+    } else {
+      warnings.push("ambiguous-bus");
+      for (const target of arrowEnds) {
+        if (plainEnds.length > 0) pushEdge(plainEnds[0].boxIdx, target.boxIdx, true);
+      }
+    }
+  }
+  if (mergedParallel) warnings.push("parallel-edges-merged");
+  edges.sort(
+    (a, b) => a.source.localeCompare(b.source) || a.target.localeCompare(b.target) || (a.label ?? "").localeCompare(b.label ?? "")
+  );
+  const edgeCells = /* @__PURE__ */ new Set();
+  for (const component of components) {
+    for (const idx of component) {
+      if (!looseComponents.has(idx)) edgeCells.add(idx);
+    }
+  }
+  for (const idx of sideLabelCells) edgeCells.add(idx);
+  return { edges, edgeCells };
+}
+function asciiArrowGate(grid, r, c, dir) {
+  const behind = dir === "down" ? grid[r - 1]?.[c] : dir === "up" ? grid[r + 1]?.[c] : dir === "right" ? grid[r]?.[c - 1] : grid[r]?.[c + 1];
+  if (behind === void 0) return false;
+  return dir === "down" || dir === "up" ? isVert(behind) : isHoriz(behind);
+}
+function snapEndpoint(r, c, arrow, perimeterOwners, boxes, W, H) {
+  const ownersAt = (rr, cc) => {
+    if (rr < 0 || rr >= H || cc < 0 || cc >= W) return [];
+    return perimeterOwners.get(rr * W + cc) ?? [];
+  };
+  if (arrow) {
+    const [dr, dc] = arrow === "down" ? [1, 0] : arrow === "up" ? [-1, 0] : arrow === "right" ? [0, 1] : [0, -1];
+    for (const dist of [1, 2]) {
+      const pointed = ownersAt(r + dr * dist, c + dc * dist);
+      if (pointed.length > 0) {
+        const sorted = [...pointed].sort((a, b) => {
+          const da = directionDepth(boxes[a], r + dr * dist, c + dc * dist, arrow);
+          const db = directionDepth(boxes[b], r + dr * dist, c + dc * dist, arrow);
+          return db - da || a - b;
+        });
+        return sorted[0];
+      }
+    }
+  }
+  const candidates = /* @__PURE__ */ new Map();
+  for (const [dr, dc, priority] of [
+    [-1, 0, 0],
+    [1, 0, 0],
+    [0, -1, 0],
+    [0, 1, 0],
+    [-1, -1, 1],
+    [-1, 1, 1],
+    [1, -1, 1],
+    [1, 1, 1],
+    [-2, 0, 2],
+    [2, 0, 2],
+    [0, -2, 2],
+    [0, 2, 2]
+  ]) {
+    for (const owner of ownersAt(r + dr, c + dc)) {
+      const existing = candidates.get(owner);
+      if (existing === void 0 || priority < existing) candidates.set(owner, priority);
+    }
+  }
+  if (candidates.size === 0) return null;
+  const ranked = [...candidates.entries()].sort(
+    (a, b) => a[1] - b[1] || boxes[a[0]].r0 - boxes[b[0]].r0 || boxes[a[0]].c0 - boxes[b[0]].c0 || a[0] - b[0]
+  );
+  return ranked[0][0];
+}
+function directionDepth(box, r, c, arrow) {
+  switch (arrow) {
+    case "down":
+      return box.r0 === r ? 1 : 0;
+    // arrow points down at the box's TOP border
+    case "up":
+      return box.r1 === r ? 1 : 0;
+    case "right":
+      return box.c0 === c ? 1 : 0;
+    case "left":
+      return box.c1 === c ? 1 : 0;
+  }
+}
+function truncate(s, max) {
+  return s.length > max ? `${s.slice(0, max - 1)}\u2026` : s;
+}
+
+// src/doc/asciiDiagram/detect.ts
+var ASCII_DIAGRAM_FENCE_LANGS = /* @__PURE__ */ new Set([
+  "text",
+  "txt",
+  "plaintext",
+  "plain",
+  "ascii",
+  "diagram"
+]);
+var MAX_LINES = 400;
+var MAX_COLS = 400;
+var MIN_LINES = 3;
+var MAX_LOOSE_RATIO = 0.25;
+var STRUCTURAL_IN_LABEL = /[│┃║┌┐└┘├┤┬┴┼╭╮╰╯┏┓┗┛╔╗╚╝┣┫┳┻╋╠╣╦╩╬╞╡╥╨╫╪]/;
+function isEligibleAsciiFenceLang(lang) {
+  if (lang === null || lang === void 0) return true;
+  const normalized = lang.trim().toLowerCase();
+  return normalized === "" || ASCII_DIAGRAM_FENCE_LANGS.has(normalized);
+}
+function isExplicitDiagramLang(lang) {
+  return typeof lang === "string" && lang.trim().toLowerCase() === "diagram";
+}
+function detectAsciiDiagram(text, opts = {}) {
+  const explicit = opts.explicit === true;
+  const reasons = [];
+  const lines = text.replace(/\r\n?/g, "\n").split("\n");
+  if (lines.length < MIN_LINES) {
+    return { isDiagram: false, reasons: [`too-few-lines(${lines.length})`] };
+  }
+  if (lines.length > MAX_LINES) {
+    return { isDiagram: false, reasons: [`too-many-lines(${lines.length})`] };
+  }
+  let maxCols = 0;
+  for (const line of lines) maxCols = Math.max(maxCols, line.length);
+  if (maxCols > MAX_COLS) {
+    return { isDiagram: false, reasons: [`too-wide(${maxCols})`] };
+  }
+  if (!explicit) {
+    let tlCandidates = 0;
+    for (const line of lines) {
+      const unicodeMatches = line.match(/[┌╭┏╔]|[├┬┼┣┳╋╠╦╬][─━═]/gu);
+      tlCandidates += unicodeMatches ? unicodeMatches.length : 0;
+      const plusMatches = line.match(/\+[-+]/g);
+      tlCandidates += plusMatches ? plusMatches.length : 0;
+    }
+    if (tlCandidates < 2) {
+      return { isDiagram: false, reasons: [`too-few-corner-candidates(${tlCandidates})`] };
+    }
+  }
+  const nonBlank = lines.filter((l) => l.trim().length > 0);
+  const pipeRows = nonBlank.filter((l) => /^\s*\|.*\|\s*$/.test(l)).length;
+  const hasGfmSeparator = nonBlank.some((l) => /^\s*\|?[\s:|-]+\|?\s*$/.test(l) && l.includes("-"));
+  if (pipeRows > nonBlank.length / 2 && hasGfmSeparator) {
+    return { isDiagram: false, reasons: ["markdown-table"] };
+  }
+  const { diagram, stats } = parseAsciiDiagramWithStats(text);
+  const minBoxes = explicit ? 1 : 2;
+  if (diagram.nodes.length < minBoxes) {
+    return { isDiagram: false, reasons: [`too-few-boxes(${diagram.nodes.length})`] };
+  }
+  const garbled = diagram.nodes.filter((n) => STRUCTURAL_IN_LABEL.test(n.label)).length;
+  if (garbled > 0 && garbled >= diagram.nodes.length * 0.25) {
+    return { isDiagram: false, reasons: [`garbled-labels(${garbled}/${diagram.nodes.length})`] };
+  }
+  if (!explicit) {
+    if (diagram.edges.length === 0 && diagram.nodes.length >= 4 && isLattice(diagram)) {
+      return { isDiagram: false, reasons: ["table-lattice"] };
+    }
+    if (stats.totalNonSpaceCells > 0) {
+      const looseRatio = stats.looseNonSpaceCells / stats.totalNonSpaceCells;
+      if (looseRatio > MAX_LOOSE_RATIO) {
+        return { isDiagram: false, reasons: [`loose-ratio(${looseRatio.toFixed(2)})`] };
+      }
+    }
+  }
+  reasons.push(`boxes(${diagram.nodes.length})`, `edges(${diagram.edges.length})`);
+  if (explicit) reasons.push("explicit");
+  return { isDiagram: true, diagram, reasons };
+}
+function isAsciiDiagramFence(node) {
+  if (node.type !== "code") return false;
+  if (!isEligibleAsciiFenceLang(node.lang)) return false;
+  return detectAsciiDiagram(node.value, { explicit: isExplicitDiagramLang(node.lang) }).isDiagram;
+}
+function isLattice(diagram) {
+  const leaves = diagram.nodes.filter((n) => !n.containerId);
+  if (leaves.length < 4) return false;
+  const rowBands = new Set(leaves.map((n) => n.row));
+  const colBands = new Set(leaves.map((n) => n.col));
+  if (rowBands.size < 2 || colBands.size < 2) return false;
+  return leaves.every(
+    (a) => leaves.some((b) => {
+      if (a === b) return false;
+      const aR1 = a.row + a.hRows - 1;
+      const aC1 = a.col + a.wCols - 1;
+      const bR1 = b.row + b.hRows - 1;
+      const bC1 = b.col + b.wCols - 1;
+      return a.row === bR1 || aR1 === b.row || a.col === bC1 || aC1 === b.col;
+    })
+  );
+}
+
+// src/doc/asciiTimeline/wrappedFlow.ts
+var UNDERLINE_RE = /[─━═-]{6,}/gu;
+var FLOW_CHAR_RE = /[─━═│|►◄→←┌┐└┘├┤]/u;
+var ARROW_RE = /[►◄→←]/u;
+var LEFT_ARROW_RE = /[◄←]/u;
+var RIGHT_ARROW_RE = /[►→]/u;
+var CONNECTOR_ONLY_RE = /^[\s─━═│|►◄→←┌┐└┘├┤]+$/u;
+var HEADER_RE = /^[A-Z][A-Z0-9 _/-]*(?:\s+\([^)]*\))?$/u;
+function parseWrappedFlowTimeline(text) {
+  const lines = text.replace(/\r\n?/g, "\n").split("\n");
+  const header = findHeader(lines);
+  if (!header || header.tracks.length < 2) return null;
+  const drafts = [];
+  const links = [];
+  const usedIds = /* @__PURE__ */ new Set();
+  const lastByTrack = /* @__PURE__ */ new Map();
+  let pendingDescription = null;
+  let activeBranchRoot = null;
+  let wrapSource = null;
+  let arrowCount = 0;
+  let hasLeftArrow = false;
+  let hasRightArrow = false;
+  let hasWrapTop = false;
+  let hasWrapBottom = false;
+  const addEvent = (segment) => {
+    const label = normalizeText(segment.text);
+    const id = uniqueId(label, usedIds);
+    const draft = {
+      id,
+      label,
+      trackIndex: segment.trackIndex,
+      order: drafts.length
+    };
+    drafts.push(draft);
+    return draft;
+  };
+  const addLink = (source, target, label) => {
+    if (!source || !target || source === target) return;
+    if (links.some((link) => link.source === source && link.target === target && link.label === label)) {
+      return;
+    }
+    links.push({ source, target, ...label ? { label } : {} });
+  };
+  for (let row = header.underlineRow + 1; row < lines.length; row++) {
+    const original = lines[row];
+    if (!original.trim()) continue;
+    if (CONNECTOR_ONLY_RE.test(original)) {
+      hasWrapTop || (hasWrapTop = original.includes("\u2510"));
+      hasWrapBottom || (hasWrapBottom = original.includes("\u2518"));
+      continue;
+    }
+    const trimmed = original.trim();
+    if (trimmed.startsWith("(") && !ARROW_RE.test(original)) {
+      const trackIndex = trackIndexAt(header.tracks, firstContentColumn(original));
+      const eventId = lastByTrack.get(trackIndex);
+      if (!eventId) return null;
+      pendingDescription = {
+        eventId,
+        text: normalizeText(original.replace(/[│|]+\s*$/u, ""))
+      };
+      continue;
+    }
+    let line = original;
+    let continuationTarget = null;
+    if (pendingDescription) {
+      const firstArrow = firstArrowColumn(line);
+      if (firstArrow < 0) return null;
+      const continuation = normalizeText(Array.from(line).slice(0, firstArrow).join(""));
+      const event = drafts.find((candidate) => candidate.id === pendingDescription?.eventId);
+      if (!event) return null;
+      event.description = normalizeText(`${pendingDescription.text} ${continuation}`);
+      continuationTarget = event.id;
+      line = `${" ".repeat(firstArrow)}${Array.from(line).slice(firstArrow).join("")}`;
+      pendingDescription = null;
+    }
+    const segments = extractSegments(line, header.tracks);
+    if (segments.length === 0) return null;
+    if (segments.some((segment) => !/[\p{L}\p{N}]/u.test(segment.text))) return null;
+    const previousByTrack = new Map(lastByTrack);
+    const events = segments.map(addEvent);
+    const directions = [];
+    for (let index = 0; index < segments.length - 1; index++) {
+      const between = Array.from(line).slice(segments[index].end + 1, segments[index + 1].start).join("");
+      const direction = LEFT_ARROW_RE.test(between) ? "left" : RIGHT_ARROW_RE.test(between) ? "right" : null;
+      directions.push(direction);
+      if (direction) arrowCount++;
+      hasLeftArrow || (hasLeftArrow = direction === "left");
+      hasRightArrow || (hasRightArrow = direction === "right");
+      if (direction === "left") addLink(events[index + 1].id, events[index].id);
+      if (direction === "right") addLink(events[index].id, events[index + 1].id);
+    }
+    const leadingBranch = /^[\s│|]*[├└]/u.exec(original)?.[0] ?? "";
+    if (leadingBranch) {
+      if (!activeBranchRoot) {
+        activeBranchRoot = previousByTrack.get(events[0].trackIndex) ?? null;
+      }
+      addLink(activeBranchRoot ?? void 0, events[0].id);
+      if (leadingBranch.includes("\u2514")) activeBranchRoot = null;
+    } else {
+      activeBranchRoot = null;
+    }
+    const allLeft = directions.length > 0 && directions.every((direction) => direction === "left");
+    const ordered = allLeft ? [...events].reverse() : events;
+    const first = ordered[0];
+    if (!leadingBranch && !original.includes("\u2518")) {
+      addLink(previousByTrack.get(first.trackIndex), first.id);
+    }
+    if (continuationTarget) addLink(ordered[ordered.length - 1]?.id, continuationTarget);
+    for (const event of ordered) lastByTrack.set(event.trackIndex, event.id);
+    if (original.includes("\u2510")) {
+      hasWrapTop = true;
+      wrapSource = events[events.length - 1]?.id ?? null;
+    }
+    if (original.includes("\u2518")) {
+      hasWrapBottom = true;
+      const target = allLeft ? events[0]?.id : events[events.length - 1]?.id;
+      addLink(wrapSource ?? void 0, target);
+    }
+  }
+  if (pendingDescription || drafts.length < 6) return null;
+  if (arrowCount < 4 || !hasLeftArrow || !hasRightArrow || !hasWrapTop || !hasWrapBottom) {
+    return null;
+  }
+  if (!hasCrossTrackLink(drafts, links)) return null;
+  const columns = assignColumns(drafts, links);
+  const endColumn = Math.max(10, ...columns.values());
+  const tracks = header.tracks.map((band, trackIndex) => {
+    const trackEvents = drafts.filter((event) => event.trackIndex === trackIndex).sort(
+      (left, right) => (columns.get(left.id) ?? 0) - (columns.get(right.id) ?? 0) || left.order - right.order
+    );
+    let previousColumn = -1;
+    const events = trackEvents.map((event, index) => {
+      const ideal = columns.get(event.id) ?? index * 10;
+      const column = Math.max(previousColumn + 1, ideal);
+      previousColumn = column;
+      return {
+        id: event.id,
+        label: event.label,
+        ...event.description ? { description: event.description } : {},
+        column,
+        side: index % 2 === 0 ? "above" : "below",
+        marker: "filled"
+      };
+    });
+    return {
+      id: band.id,
+      label: band.label,
+      row: band.row,
+      startColumn: 0,
+      endColumn,
+      events
+    };
+  });
+  const width = Math.max(0, ...lines.map((line) => Array.from(line).length));
+  links.sort(
+    (left, right) => left.source.localeCompare(right.source) || left.target.localeCompare(right.target) || (left.label ?? "").localeCompare(right.label ?? "")
+  );
+  return {
+    tracks,
+    links,
+    width,
+    height: lines.length,
+    style: "unicode",
+    warnings: []
+  };
+}
+function isWrappedFlowTimelineSource(text) {
+  return parseWrappedFlowTimeline(text) !== null;
+}
+function findHeader(lines) {
+  for (let row = 1; row < Math.min(lines.length, 5); row++) {
+    const runs = Array.from(lines[row].matchAll(UNDERLINE_RE)).map((match) => ({
+      start: match.index,
+      end: (match.index ?? 0) + Array.from(match[0]).length - 1
+    }));
+    if (runs.length < 2) continue;
+    const headings = splitHeader(lines[row - 1]);
+    if (headings.length !== runs.length || headings.some((heading) => !HEADER_RE.test(heading.text))) {
+      continue;
+    }
+    const tracks = runs.map((run, index) => {
+      const heading = headings[index];
+      const base = heading.text.replace(/\s+\([^)]*\)\s*$/u, "").trim();
+      return {
+        id: safeId(base),
+        label: heading.text,
+        row: row - 1,
+        start: run.start,
+        end: run.end
+      };
+    });
+    return { tracks, underlineRow: row };
+  }
+  return null;
+}
+function splitHeader(line) {
+  const chars = Array.from(line);
+  const segments = [];
+  let start = -1;
+  let spaces = 0;
+  for (let index = 0; index <= chars.length; index++) {
+    const char = chars[index];
+    if (char === " ") {
+      spaces++;
+      if (start >= 0 && spaces >= 3) {
+        const end = index - spaces;
+        const text = chars.slice(start, end + 1).join("").trim();
+        if (text) segments.push({ text, start, end });
+        start = -1;
+      }
+      continue;
+    }
+    spaces = 0;
+    if (char !== void 0 && start < 0) start = index;
+    if (char === void 0 && start >= 0) {
+      const text = chars.slice(start).join("").trim();
+      if (text) segments.push({ text, start, end: chars.length - 1 });
+    }
+  }
+  return segments;
+}
+function extractSegments(line, tracks) {
+  const chars = Array.from(line);
+  const segments = [];
+  let start = -1;
+  for (let index = 0; index <= chars.length; index++) {
+    const structural = index === chars.length || FLOW_CHAR_RE.test(chars[index] ?? "");
+    if (!structural && start < 0) start = index;
+    if (!structural || start < 0) continue;
+    const raw = chars.slice(start, index).join("");
+    const leading = raw.length - raw.trimStart().length;
+    const text = normalizeText(raw);
+    if (text) {
+      const segmentStart = start + leading;
+      const segmentEnd = segmentStart + Array.from(text).length - 1;
+      segments.push({
+        text,
+        start: segmentStart,
+        end: segmentEnd,
+        trackIndex: trackIndexAt(tracks, segmentStart)
+      });
+    }
+    start = -1;
+  }
+  return segments;
+}
+function trackIndexAt(tracks, column) {
+  for (let index = 1; index < tracks.length; index++) {
+    if (column < tracks[index].start) return index - 1;
+  }
+  return tracks.length - 1;
+}
+function firstContentColumn(line) {
+  const chars = Array.from(line);
+  const index = chars.findIndex((char) => /[\p{L}\p{N}(]/u.test(char));
+  return Math.max(0, index);
+}
+function firstArrowColumn(line) {
+  return Array.from(line).findIndex((char) => ARROW_RE.test(char));
+}
+function normalizeText(value) {
+  return value.normalize("NFC").replace(/^[\s:]+|[\s:]+$/gu, "").replace(/\s+/gu, " ").trim();
+}
+function safeId(value) {
+  return value.normalize("NFC").toLowerCase().replace(/[^a-z0-9_.~-]+/gu, "-").replace(/^-+|-+$/gu, "") || "event";
+}
+function uniqueId(label, used) {
+  const base = safeId(label);
+  if (!used.has(base)) {
+    used.add(base);
+    return base;
+  }
+  let suffix = 2;
+  while (used.has(`${base}-${suffix}`)) suffix++;
+  const id = `${base}-${suffix}`;
+  used.add(id);
+  return id;
+}
+function hasCrossTrackLink(events, links) {
+  const trackById = new Map(events.map((event) => [event.id, event.trackIndex]));
+  return links.some((link) => trackById.get(link.source) !== trackById.get(link.target));
+}
+function assignColumns(events, links) {
+  const outgoing = /* @__PURE__ */ new Map();
+  const indegree = new Map(events.map((event) => [event.id, 0]));
+  for (const link of links) {
+    outgoing.set(link.source, [...outgoing.get(link.source) ?? [], link.target]);
+    indegree.set(link.target, (indegree.get(link.target) ?? 0) + 1);
+  }
+  const ranks = new Map(events.map((event) => [event.id, 0]));
+  const queue = events.filter((event) => indegree.get(event.id) === 0).map((event) => event.id);
+  let visited = 0;
+  while (queue.length > 0) {
+    const source = queue.shift();
+    visited++;
+    for (const target of outgoing.get(source) ?? []) {
+      ranks.set(target, Math.max(ranks.get(target) ?? 0, (ranks.get(source) ?? 0) + 1));
+      const next = (indegree.get(target) ?? 1) - 1;
+      indegree.set(target, next);
+      if (next === 0) queue.push(target);
+    }
+  }
+  if (visited < events.length) {
+    for (const event of events) ranks.set(event.id, event.order);
+  }
+  return new Map(Array.from(ranks, ([id, rank]) => [id, rank * 10]));
+}
+
+// src/doc/asciiTimeline/parse.ts
+var STRONG_MARKERS = /* @__PURE__ */ new Set(["\u25CF", "\u25CB", "\u25C9", "\u25C6", "\u25C7", "\u2022"]);
+var ASCII_MARKERS = /* @__PURE__ */ new Set(["*", "o", "O"]);
+var HORIZONTAL = /* @__PURE__ */ new Set(["\u2500", "\u2501", "\u2550", "\u254C", "\u254D", "\u2504", "\u2505", "\u2508", "\u2509", "-"]);
+var END_ARROWS = /* @__PURE__ */ new Set(["\u25BA", "\u25B6", "\u25B7", "\u2192", ">"]);
+var POINTERS = /* @__PURE__ */ new Set(["\u25B2", "\u25B3", "\u25BC", "\u25BD", "^", "v"]);
+var CONNECTOR_ANCHORS = /* @__PURE__ */ new Set(["\u2514", "\u250C", "\u251C", "\u252C", "\u2518", "\u2510", "\u2570", "\u256D", "\u256F", "\u256E"]);
+function parseAsciiTimeline(text) {
+  return parseAsciiTimelineWithStats(text).timeline;
+}
+function parseAsciiTimelineWithStats(text) {
+  const lines = text.replace(/\r\n?/g, "\n").split("\n");
+  const width = Math.max(0, ...lines.map((line) => Array.from(line).length));
+  const wrappedFlow = parseWrappedFlowTimeline(text);
+  if (wrappedFlow) {
+    const markerCount = wrappedFlow.tracks.reduce((sum, track) => sum + track.events.length, 0);
+    return {
+      timeline: wrappedFlow,
+      stats: {
+        axisLines: wrappedFlow.tracks.length,
+        markerCount,
+        strongMarkerCount: markerCount,
+        horizontalChars: Array.from(text).filter((char) => HORIZONTAL.has(char)).length,
+        pointerCount: 0,
+        branchDeclarations: wrappedFlow.links.length,
+        wrappedFlow: true
+      }
+    };
+  }
+  const style = detectStyle2(lines);
+  const pendingBranches = [];
+  const axes = [];
+  for (let row = 0; row < lines.length; row++) {
+    const branch = parseBranchDeclaration(lines[row]);
+    if (branch) {
+      pendingBranches.push(branch);
+      continue;
+    }
+    const axis = analyzeAxisLine(lines[row], row, style);
+    if (axis) {
+      axes.push(axis);
+      continue;
+    }
+    const cadence = analyzeCadenceLine(lines[row], row);
+    if (cadence) axes.push(cadence);
+  }
+  const tracks = axes.map((axis, index) => ({
+    id: axis.id ?? slug(axis.label || `track-${index + 1}`),
+    ...axis.label ? { label: axis.label } : {},
+    ...axis.endLabel ? { endLabel: axis.endLabel } : {},
+    row: axis.row,
+    startColumn: axis.startColumn,
+    endColumn: axis.endColumn,
+    events: axis.markerColumns.map((markerColumn, eventIndex) => {
+      const inline = axis.inline[eventIndex];
+      return {
+        id: inline.id ?? "",
+        label: inline.label ?? "",
+        ...inline.description ? { description: inline.description } : {},
+        column: inline.column ?? markerColumn,
+        ...inline.side ? { side: inline.side } : {},
+        ...inline.descriptionSide ? { descriptionSide: inline.descriptionSide } : {},
+        ...inline.callout === false ? { callout: false } : {},
+        marker: markerKind(axis.markerGlyphs[eventIndex])
+      };
+    })
+  }));
+  for (let i = 0; i < axes.length; i++) {
+    const axis = axes[i];
+    const track = tracks[i];
+    const aboveRow = previousNonBlankRow(lines, axis.row - 1);
+    if (aboveRow >= 0 && !axes.some((candidate) => candidate.row === aboveRow)) {
+      const segments = splitPlainSegments(lines[aboveRow]);
+      const pointEvents = track.events.filter((event) => !event.label);
+      const aligned = alignedEventSegments(segments, pointEvents);
+      if (aligned) {
+        for (let eventIndex = 0; eventIndex < pointEvents.length; eventIndex++) {
+          pointEvents[eventIndex].label = cleanProseText(aligned[eventIndex].text);
+          pointEvents[eventIndex].side = "above";
+        }
+        const firstAligned = segments.indexOf(aligned[0]);
+        const prefix = firstAligned > 0 ? segments[firstAligned - 1] : void 0;
+        if (prefix?.text.trim().endsWith(":")) {
+          track.label = stripTrailingColon(prefix.text);
+          track.id = slug(track.label);
+        }
+      }
+      for (const event of track.events) {
+        if (event.label) continue;
+        const gap = nearestEventGap(track.events, event.column);
+        const threshold = Math.max(3, Math.min(8, gap * 0.38));
+        const nearest = nearestSegment(segments, event.column, threshold);
+        if (!nearest) continue;
+        event.label = cleanProseText(nearest.text);
+        event.side = "above";
+      }
+    }
+  }
+  let pointerCount = 0;
+  for (let row = 0; row < lines.length; row++) {
+    if (axes.some((axis) => axis.row === row)) continue;
+    const chars = Array.from(lines[row]);
+    const pointerColumns = chars.map((char, column) => ({ char, column })).filter(({ column }) => isPointerAt(chars, column)).map(({ column }) => column);
+    for (let pointerIndex = 0; pointerIndex < pointerColumns.length; pointerIndex++) {
+      const column = pointerColumns[pointerIndex];
+      const track = nearestUnclaimedMarkerTrack(tracks, row, column) ?? nearestTrack(tracks, row, column);
+      if (!track) continue;
+      pointerCount++;
+      const nextPointer = pointerColumns[pointerIndex + 1] ?? chars.length;
+      const after = cleanProseText(chars.slice(column + 1, nextPointer).join(""));
+      const prefix = pointerIndex === 0 ? cleanProseText(chars.slice(0, column).join("")) : "";
+      const parsed = /\{[^{}]*#[^{}\s]+[^{}]*\}\s*$/u.test(after) ? parseInlineEvent(after) : { label: after || void 0 };
+      const label = stripTrailingColon(prefix) || parsed.label || after || `Event ${track.events.length + 1}`;
+      const description = prefix && after ? after : parsed.description;
+      const side = parsed.side ?? (row < track.row ? "above" : "below");
+      const existing = track.events.find((event) => !event.id && Math.abs(event.column - column) <= 1) ?? track.events.find(
+        (event) => event.callout !== false && Math.abs(event.column - column) <= 1
+      );
+      if (existing) {
+        if (parsed.id) existing.id = parsed.id;
+        if (parsed.column !== void 0) existing.column = parsed.column;
+        if (!existing.label) existing.label = label;
+        if (parsed.label) existing.label = parsed.label;
+        if (description && !existing.description) existing.description = description;
+        if (parsed.description) existing.description = parsed.description;
+        if (parsed.descriptionSide) existing.descriptionSide = parsed.descriptionSide;
+        else if (description && !parsed.id) existing.descriptionSide ?? (existing.descriptionSide = side);
+        if (parsed.callout !== void 0) existing.callout = parsed.callout;
+        existing.side = side;
+      } else {
+        track.events.push({
+          id: parsed.id ?? "",
+          label,
+          ...description ? { description } : {},
+          column: parsed.column ?? column,
+          side,
+          ...parsed.descriptionSide ? { descriptionSide: parsed.descriptionSide } : description && !parsed.id ? { descriptionSide: side } : {},
+          ...parsed.callout !== void 0 ? { callout: parsed.callout } : {},
+          marker: "hollow"
+        });
+      }
+    }
+  }
+  for (let row = 0; row < lines.length; row++) {
+    if (axes.some((axis) => axis.row === row)) continue;
+    const callouts = extractConnectorCallouts(lines[row]);
+    const prefix = callouts.length > 0 ? cleanProseText(Array.from(lines[row]).slice(0, callouts[0].start).join("")) : "";
+    for (let calloutIndex = 0; calloutIndex < callouts.length; calloutIndex++) {
+      const callout = callouts[calloutIndex];
+      const track = nearestTrack(tracks, row, callout.start);
+      if (!track || track.events.length === 0) continue;
+      const event = nearestEvent(track.events, callout.start);
+      if (!event) continue;
+      const calloutText = cleanProseText(callout.text);
+      const cleaned = calloutIndex === 0 && prefix ? `${prefix} ${calloutText}` : calloutText;
+      if (!cleaned || cleaned === event.label) continue;
+      if (event.callout === false) {
+        event.callout = true;
+        event.label = cleaned;
+        event.side = row < track.row ? "above" : "below";
+        continue;
+      }
+      event.description = event.description ? `${event.description} ${cleaned}` : cleaned;
+      event.descriptionSide ?? (event.descriptionSide = row < track.row ? "above" : "below");
+      event.side ?? (event.side = row < track.row ? "above" : "below");
+    }
+  }
+  const warnings = [];
+  const usedTrackIds = /* @__PURE__ */ new Map();
+  for (const track of tracks) track.id = dedupe(track.id, usedTrackIds);
+  const usedEventIds = /* @__PURE__ */ new Map();
+  for (const track of tracks) {
+    track.events.sort((a, b) => a.column - b.column);
+    for (let i = 0; i < track.events.length; i++) {
+      const event = track.events[i];
+      if (!event.label) {
+        event.label = `Event ${i + 1}`;
+        warnings.push(`unlabeled-event(${track.id}:${event.column})`);
+      }
+      event.id = dedupe(event.id || slug(event.label), usedEventIds);
+      event.side ?? (event.side = i % 2 === 0 ? "above" : "below");
+    }
+  }
+  const eventIds = new Set(tracks.flatMap((track) => track.events.map((event) => event.id)));
+  const labelToId = /* @__PURE__ */ new Map();
+  for (const track of tracks) {
+    for (const event of track.events) {
+      labelToId.set(slug(event.label), event.id);
+      labelToId.set(event.id, event.id);
+    }
+  }
+  const links = [];
+  for (const branch of pendingBranches) {
+    const source = labelToId.get(slug(branch.source)) ?? branch.source;
+    const target = labelToId.get(slug(branch.target)) ?? branch.target;
+    if (!eventIds.has(source) || !eventIds.has(target)) {
+      warnings.push(`unresolved-link(${branch.source}->${branch.target})`);
+      continue;
+    }
+    links.push({ source, target, ...branch.label ? { label: branch.label } : {} });
+  }
+  const stats = {
+    axisLines: axes.length,
+    markerCount: axes.reduce((sum, axis) => sum + axis.markerColumns.length, 0),
+    strongMarkerCount: axes.reduce((sum, axis) => sum + axis.strongMarkerCount, 0),
+    horizontalChars: axes.reduce((sum, axis) => sum + axis.horizontalChars, 0),
+    pointerCount,
+    branchDeclarations: pendingBranches.length,
+    wrappedFlow: false
+  };
+  return {
+    timeline: { tracks, links, width, height: lines.length, style, warnings },
+    stats
+  };
+}
+function alignedEventSegments(segments, events) {
+  if (events.length < 2 || segments.length < events.length) return void 0;
+  const candidates = segments.slice(-events.length);
+  if (candidates.some((segment) => cleanCalloutText(segment.text).length > 40)) return void 0;
+  const offsets = candidates.map(
+    (segment, index) => (segment.start + segment.end) / 2 - events[index].column
+  );
+  const spread = Math.max(...offsets) - Math.min(...offsets);
+  return spread <= 3 ? [...candidates] : void 0;
+}
+function analyzeAxisLine(line, row, style) {
+  const chars = Array.from(line);
+  const markerColumns = [];
+  const markerGlyphs = [];
+  let horizontalChars = 0;
+  let strongMarkerCount = 0;
+  for (let i = 0; i < chars.length; i++) {
+    const ch = chars[i];
+    if (HORIZONTAL.has(ch)) horizontalChars++;
+    if (isMarkerAt(chars, i, style)) {
+      markerColumns.push(i);
+      markerGlyphs.push(ch);
+      if (STRONG_MARKERS.has(ch)) strongMarkerCount++;
+    }
+  }
+  if (markerColumns.length === 0 || horizontalChars < 2) return null;
+  const firstMarker = markerColumns[0];
+  const colon = chars.slice(0, firstMarker).lastIndexOf(":");
+  let startColumn;
+  if (colon >= 0) {
+    startColumn = colon + 1;
+    while (chars[startColumn] === " ") startColumn++;
+  } else {
+    let i = firstMarker - 1;
+    while (i >= 0 && (HORIZONTAL.has(chars[i]) || chars[i] === " ")) i--;
+    startColumn = i + 1;
+    while (chars[startColumn] === " ") startColumn++;
+  }
+  let endColumn = markerColumns[markerColumns.length - 1];
+  const arrowSearchStart = endColumn + 1;
+  const arrowColumn = chars.findIndex(
+    (ch, index) => index >= arrowSearchStart && END_ARROWS.has(ch) && hasRailBefore(chars, index, ch === ">" ? 3 : 2)
+  );
+  let payloadEndExclusive;
+  if (arrowColumn >= 0) {
+    endColumn = arrowColumn;
+    payloadEndExclusive = arrowColumn;
+  } else {
+    const lastNonSpace = findLastNonSpace(chars);
+    endColumn = Math.max(endColumn, lastNonSpace);
+    payloadEndExclusive = endColumn + 1;
+  }
+  const prefix = parseTrackPrefix(stripTrailingColon(chars.slice(0, startColumn).join("").trim()));
+  const suffix = cleanProseText(chars.slice(endColumn + 1).join(""));
+  const label = prefix.label;
+  const inline = markerColumns.map((column, index) => {
+    const next = index + 1 < markerColumns.length ? markerColumns[index + 1] : payloadEndExclusive;
+    return parseInlineEvent(chars.slice(column + 1, next).join(""));
+  });
+  return {
+    row,
+    ...prefix.id ? { id: prefix.id } : {},
+    startColumn: prefix.startColumn ?? startColumn,
+    endColumn: prefix.endColumn ?? Math.max(endColumn, startColumn + 1),
+    markerColumns,
+    markerGlyphs,
+    inline,
+    ...label ? { label } : {},
+    ...suffix ? { endLabel: suffix } : {},
+    horizontalChars,
+    strongMarkerCount
+  };
+}
+function analyzeCadenceLine(line, row) {
+  const chars = Array.from(line);
+  const colon = chars.indexOf(":");
+  if (colon < 0) return null;
+  const label = chars.slice(0, colon).join("").trim();
+  if (!label) return null;
+  const tokens = [];
+  let index = colon + 1;
+  while (index < chars.length) {
+    while (index < chars.length && /\s/u.test(chars[index])) index++;
+    if (index >= chars.length) break;
+    const start = index;
+    while (index < chars.length && !/\s/u.test(chars[index])) index++;
+    tokens.push({ value: chars.slice(start, index).join(""), column: start });
+  }
+  if (tokens.length < 4 || tokens[0].value.length !== 1 || tokens.some((token) => token.value !== tokens[0].value)) {
+    return null;
+  }
+  return {
+    row,
+    startColumn: tokens[0].column,
+    endColumn: tokens[tokens.length - 1].column,
+    markerColumns: tokens.map((token) => token.column),
+    markerGlyphs: tokens.map(() => "\u25CB"),
+    inline: tokens.map((token, tokenIndex) => ({
+      label: token.value,
+      id: `${slug(label)}-${tokenIndex + 1}`,
+      column: token.column,
+      callout: false
+    })),
+    label,
+    horizontalChars: 0,
+    strongMarkerCount: 0
+  };
+}
+function parseInlineEvent(raw) {
+  let text = stripEdgeRails(raw).replace(/\s+/g, " ").trim();
+  if (!text) return {};
+  let id;
+  let column;
+  let side;
+  let descriptionSide;
+  let callout;
+  const attrs = /\{([^{}]+)\}\s*$/.exec(text);
+  if (attrs) {
+    let recognized = false;
+    for (const token of attrs[1].trim().split(/\s+/)) {
+      if (token.startsWith("#") && token.length > 1) {
+        id = token.slice(1);
+        recognized = true;
+      } else if (token === "side=above") {
+        side = "above";
+        recognized = true;
+      } else if (token === "side=below") {
+        side = "below";
+        recognized = true;
+      } else if (token === "descriptionSide=above") {
+        descriptionSide = "above";
+        recognized = true;
+      } else if (token === "descriptionSide=below") {
+        descriptionSide = "below";
+        recognized = true;
+      } else if (token.startsWith("column=")) {
+        const parsed = parseCoordinate(token.slice(7));
+        if (parsed !== void 0) {
+          column = parsed;
+          recognized = true;
+        }
+      } else if (token === "callout=false") {
+        callout = false;
+        recognized = true;
+      } else if (token === "callout=true") {
+        callout = true;
+        recognized = true;
+      }
+    }
+    if (recognized) text = text.slice(0, attrs.index).trim();
+  }
+  if (text.startsWith("^ ")) {
+    side = "above";
+    text = text.slice(2).trim();
+  } else if (/^[vV]\s+/.test(text)) {
+    side = "below";
+    text = text.slice(2).trim();
+  }
+  const separator = text.indexOf("::");
+  const label = (separator >= 0 ? text.slice(0, separator) : text).trim();
+  const description = separator >= 0 ? text.slice(separator + 2).trim() : void 0;
+  return {
+    ...label ? { label } : {},
+    ...description ? { description } : {},
+    ...id ? { id } : {},
+    ...column !== void 0 ? { column } : {},
+    ...side ? { side } : {},
+    ...descriptionSide ? { descriptionSide } : {},
+    ...callout !== void 0 ? { callout } : {}
+  };
+}
+function parseTrackPrefix(text) {
+  let label = text.trim();
+  let id;
+  let startColumn;
+  let endColumn;
+  let recognized = false;
+  const attrs = /\{([^{}]+)\}\s*$/.exec(label);
+  if (attrs) {
+    for (const token of attrs[1].trim().split(/\s+/)) {
+      if (token.startsWith("#") && token.length > 1) {
+        id = token.slice(1);
+        recognized = true;
+      } else if (token.startsWith("start=")) {
+        startColumn = parseCoordinate(token.slice(6));
+        recognized || (recognized = startColumn !== void 0);
+      } else if (token.startsWith("end=")) {
+        endColumn = parseCoordinate(token.slice(4));
+        recognized || (recognized = endColumn !== void 0);
+      }
+    }
+    if (recognized) label = label.slice(0, attrs.index).trim();
+  }
+  return {
+    ...label ? { label } : {},
+    ...id ? { id } : {},
+    ...startColumn !== void 0 ? { startColumn } : {},
+    ...endColumn !== void 0 ? { endColumn } : {},
+    hasMetadata: recognized
+  };
+}
+function parseCoordinate(value) {
+  if (!value.trim()) return void 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function stripEdgeRails(raw) {
+  const chars = Array.from(raw);
+  let start = 0;
+  let end = chars.length - 1;
+  let firstNonSpace = 0;
+  while (firstNonSpace <= end && /\s/u.test(chars[firstNonSpace])) firstNonSpace++;
+  let leadingRailEnd = firstNonSpace;
+  while (leadingRailEnd <= end && HORIZONTAL.has(chars[leadingRailEnd])) leadingRailEnd++;
+  const hasLeadingRail = leadingRailEnd > firstNonSpace;
+  const structuralLeadingRail = hasLeadingRail && (firstNonSpace === 0 || leadingRailEnd > end || /\s/u.test(chars[leadingRailEnd] ?? ""));
+  start = structuralLeadingRail ? leadingRailEnd : firstNonSpace;
+  while (start <= end && /\s/u.test(chars[start])) start++;
+  while (end >= start && /\s/u.test(chars[end])) end--;
+  const trailingRailEnd = end;
+  while (end >= start && HORIZONTAL.has(chars[end])) end--;
+  const hasTrailingRail = end < trailingRailEnd;
+  const trailingRun = hasTrailingRail ? chars.slice(end + 1, trailingRailEnd + 1) : [];
+  const structuralTrailingRail = hasTrailingRail && (end < start || /\s/u.test(chars[end] ?? "") || trailingRun.length >= 3 || trailingRun.some((char) => char !== "-"));
+  if (!structuralTrailingRail) end = trailingRailEnd;
+  while (end >= start && /\s/u.test(chars[end])) end--;
+  return chars.slice(start, end + 1).join("");
+}
+function hasRailBefore(chars, column, minimum) {
+  let index = column - 1;
+  while (index >= 0 && /\s/u.test(chars[index])) index--;
+  let count = 0;
+  while (index >= 0 && HORIZONTAL.has(chars[index])) {
+    count++;
+    index--;
+  }
+  return count >= minimum;
+}
+function findLastNonSpace(chars) {
+  for (let index = chars.length - 1; index >= 0; index--) {
+    if (!/\s/u.test(chars[index])) return index;
+  }
+  return -1;
+}
+function parseBranchDeclaration(line) {
+  const match = /^\s*(?:branch|link)\s*:\s*([^\s:]+)\s*(?:->|=>|→)\s*([^\s:]+)(?:\s*:\s*(.+))?\s*$/i.exec(line);
+  if (!match) return null;
+  return {
+    source: match[1],
+    target: match[2],
+    ...match[3]?.trim() ? { label: match[3].trim() } : {}
+  };
+}
+function splitPlainSegments(line) {
+  const chars = Array.from(line);
+  const out = [];
+  let start = -1;
+  let spaces = 0;
+  for (let i = 0; i <= chars.length; i++) {
+    const ch = chars[i];
+    if (ch === " ") {
+      spaces++;
+      if (start >= 0 && spaces >= 2) {
+        const end = i - spaces;
+        const text = chars.slice(start, end + 1).join("").trim();
+        if (text) out.push({ start, end, text });
+        start = -1;
+      }
+      continue;
+    }
+    spaces = 0;
+    if (ch !== void 0 && start < 0) start = i;
+    if (ch === void 0 && start >= 0) {
+      const text = chars.slice(start).join("").trim();
+      if (text) out.push({ start, end: chars.length - 1, text });
+    }
+  }
+  return out.filter((segment) => cleanCalloutText(segment.text).length > 0);
+}
+function extractConnectorCallouts(line) {
+  const chars = Array.from(line);
+  const out = [];
+  for (let i = 0; i < chars.length; i++) {
+    if (!CONNECTOR_ANCHORS.has(chars[i])) continue;
+    let j = i + 1;
+    const railStart = j;
+    while (j < chars.length && (HORIZONTAL.has(chars[j]) || chars[j] === " ")) j++;
+    const railEnd = j;
+    const afterRail = chars[j];
+    if (afterRail !== void 0 && !/\s/u.test(afterRail)) {
+      let lastNonAsciiRail = -1;
+      for (let railIndex = railStart; railIndex < j; railIndex++) {
+        if (HORIZONTAL.has(chars[railIndex]) && chars[railIndex] !== "-") {
+          lastNonAsciiRail = railIndex;
+        }
+      }
+      if (lastNonAsciiRail >= railStart && lastNonAsciiRail + 1 < j) {
+        j = lastNonAsciiRail + 1;
+      } else if (lastNonAsciiRail < 0 && j - railStart >= 3) {
+        j--;
+      }
+    }
+    const textStart = j;
+    if (j < railEnd) while (j < chars.length && chars[j] === "-") j++;
+    while (j < chars.length && !HORIZONTAL.has(chars[j]) && !CONNECTOR_ANCHORS.has(chars[j])) j++;
+    const text = chars.slice(textStart, j).join("").trim();
+    if (text) out.push({ start: i, end: Math.max(i, j - 1), text });
+  }
+  return out;
+}
+function nearestTrack(tracks, row, column) {
+  return tracks.filter((track) => column >= track.startColumn - 2 && column <= track.endColumn + 2).sort((a, b) => Math.abs(a.row - row) - Math.abs(b.row - row))[0];
+}
+function isPointerAt(chars, column) {
+  const char = chars[column];
+  if (!POINTERS.has(char)) return false;
+  if (char !== "^" && char !== "v") return true;
+  return (column === 0 || /\s/u.test(chars[column - 1] ?? "")) && (column + 1 >= chars.length || /\s/u.test(chars[column + 1] ?? ""));
+}
+function nearestUnclaimedMarkerTrack(tracks, row, column) {
+  return tracks.filter(
+    (track) => track.events.some((event) => !event.id && Math.abs(event.column - column) <= 1)
+  ).sort((a, b) => Math.abs(a.row - row) - Math.abs(b.row - row))[0];
+}
+function nearestEvent(events, column) {
+  return [...events].sort(
+    (a, b) => Math.abs(a.column - column) - Math.abs(b.column - column) || Number(a.callout === false) - Number(b.callout === false)
+  )[0];
+}
+function nearestSegment(segments, column, threshold) {
+  return [...segments].map((segment) => ({ segment, distance: Math.abs((segment.start + segment.end) / 2 - column) })).filter((candidate) => candidate.distance <= threshold).sort((a, b) => a.distance - b.distance)[0]?.segment;
+}
+function nearestEventGap(events, column) {
+  const gaps = events.filter((event) => event.column !== column).map((event) => Math.abs(event.column - column));
+  return gaps.length > 0 ? Math.min(...gaps) : 12;
+}
+function previousNonBlankRow(lines, from) {
+  for (let row = from; row >= 0; row--) if (lines[row].trim()) return row;
+  return -1;
+}
+function markerKind(glyph) {
+  if (glyph === "\u25C6" || glyph === "\u25C7") return "diamond";
+  if (glyph === "\u25CB" || glyph === "o" || glyph === "O") return "hollow";
+  return "filled";
+}
+function isMarkerAt(chars, index, style) {
+  const glyph = chars[index];
+  if (STRONG_MARKERS.has(glyph)) return true;
+  if (style !== "ascii" || !ASCII_MARKERS.has(glyph)) return false;
+  const leftRail = railRun(chars, index, -1);
+  const rightRail = railRun(chars, index, 1);
+  const beforeIsWord = /[\p{L}\p{N}_]/u.test(chars[index - 1] ?? "");
+  const afterIsWord = /[\p{L}\p{N}_]/u.test(chars[index + 1] ?? "");
+  return leftRail >= 2 && !afterIsWord || rightRail >= 2 && !beforeIsWord;
+}
+function railRun(chars, index, direction) {
+  let count = 0;
+  for (let cursor = index + direction; HORIZONTAL.has(chars[cursor] ?? ""); cursor += direction) {
+    count++;
+  }
+  return count;
+}
+function cleanCalloutText(text) {
+  return text.replace(/^[\s│|└┌├┬┘┐╰╭╯╮─━═╌╍┄┅┈┉-]+/u, "").replace(/[\s│|└┌├┬┘┐╰╭╯╮─━═╌╍┄┅┈┉►▶▷→>-]+$/u, "").replace(/\s+/g, " ").trim();
+}
+function cleanProseText(text) {
+  return text.replace(/^[\s│|]+/u, "").replace(/[\s│|]+$/u, "").replace(/\s+/g, " ").trim();
+}
+function stripTrailingColon(text) {
+  return text.replace(/:\s*$/, "").trim();
+}
+function slug(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "event";
+}
+function dedupe(base, used) {
+  const count = used.get(base) ?? 0;
+  used.set(base, count + 1);
+  return count === 0 ? base : `${base}-${count + 1}`;
+}
+function detectStyle2(lines) {
+  for (const line of lines) {
+    for (const ch of line) {
+      if (STRONG_MARKERS.has(ch) || HORIZONTAL.has(ch) && ch !== "-" || ["\u25BA", "\u25B6", "\u25B7", "\u2192"].includes(ch)) {
+        return "unicode";
+      }
+    }
+  }
+  return "ascii";
+}
+
+// src/doc/asciiTimeline/detect.ts
+var ASCII_TIMELINE_FENCE_LANGS = /* @__PURE__ */ new Set([
+  "text",
+  "txt",
+  "plaintext",
+  "plain",
+  "ascii",
+  "timeline"
+]);
+var MAX_LINES2 = 400;
+var MAX_CANONICAL_LINES = 2e3;
+var MAX_COLS2 = 400;
+var MAX_EXPLICIT_COLS = 4096;
+var BOX_TOP_EDGE_RE = /[┌┏╔╭].*[┐┓╗╮]/u;
+var CANONICAL_TRACK_RE = /\{#[^{}\s]+ start=[^{}\s]+ end=[^{}\s]+\}:\s/u;
+function isEligibleAsciiTimelineFenceLang(lang) {
+  if (lang === null || lang === void 0) return true;
+  const normalized = lang.trim().toLowerCase();
+  return normalized === "" || ASCII_TIMELINE_FENCE_LANGS.has(normalized);
+}
+function isExplicitTimelineLang(lang) {
+  return typeof lang === "string" && lang.trim().toLowerCase() === "timeline";
+}
+function detectAsciiTimeline(text, options = {}) {
+  const explicit = options.explicit === true;
+  const lines = text.replace(/\r\n?/g, "\n").split("\n");
+  const canonicalTrackRows = lines.filter((line) => CANONICAL_TRACK_RE.test(line)).length;
+  const canonicalLineBudget = Math.min(
+    MAX_CANONICAL_LINES,
+    canonicalTrackRows * 6 + lines.filter((line) => /^\s*(?:branch|link)\s*:/iu.test(line)).length + 2
+  );
+  if (lines.length > MAX_LINES2 && (canonicalTrackRows === 0 || lines.length > canonicalLineBudget)) {
+    return { isTimeline: false, reasons: [`too-many-lines(${lines.length})`] };
+  }
+  const maxCols = Math.max(0, ...lines.map((line) => Array.from(line).length));
+  const canonicalLongForm = canonicalTrackRows > 0 && lines.every((line) => Array.from(line).length <= MAX_COLS2 || CANONICAL_TRACK_RE.test(line));
+  const maxAllowedCols = explicit || canonicalLongForm ? MAX_EXPLICIT_COLS : MAX_COLS2;
+  if (maxCols > maxAllowedCols) {
+    return { isTimeline: false, reasons: [`too-wide(${maxCols})`] };
+  }
+  const nonBlank = lines.filter((line) => line.trim().length > 0);
+  const pipeRows = nonBlank.filter((line) => /^\s*\|.*\|\s*$/.test(line)).length;
+  const hasGfmSeparator = nonBlank.some(
+    (line) => /^\s*\|?[\s:|-]+\|?\s*$/.test(line) && line.includes("-")
+  );
+  if (pipeRows > nonBlank.length / 2 && hasGfmSeparator) {
+    return { isTimeline: false, reasons: ["markdown-table"] };
+  }
+  if (!explicit && lines.some((line) => BOX_TOP_EDGE_RE.test(line))) {
+    return { isTimeline: false, reasons: ["has-box-corners"] };
+  }
+  const boxes = parseAsciiDiagramWithStats(text).diagram.nodes.length;
+  if (boxes >= (explicit ? 2 : 1)) {
+    return { isTimeline: false, reasons: [`has-boxes(${boxes})`] };
+  }
+  if (!explicit && /^[ \t]*(?:[│|][ \t]*)*[├└+|`][─━═-]{1,4}[ \t]+[●○◉◆◇•]/mu.test(text)) {
+    return { isTimeline: false, reasons: ["tree-connector-prefix"] };
+  }
+  const { timeline, stats } = parseAsciiTimelineWithStats(text);
+  if (stats.wrappedFlow) {
+    return {
+      isTimeline: true,
+      timeline,
+      reasons: [`tracks(${stats.axisLines})`, `events(${stats.markerCount})`, "wrapped-flow"]
+    };
+  }
+  if (stats.axisLines === 0) return { isTimeline: false, reasons: ["no-axis-lines"] };
+  const explicitCadence = explicit && stats.horizontalChars === 0 && stats.markerCount >= 4;
+  if (!explicitCadence && stats.horizontalChars < (explicit ? 2 : 8)) {
+    return { isTimeline: false, reasons: [`too-few-horizontal(${stats.horizontalChars})`] };
+  }
+  if (stats.markerCount < (explicit ? 1 : 2)) {
+    return { isTimeline: false, reasons: [`too-few-markers(${stats.markerCount})`] };
+  }
+  if (!explicit && stats.strongMarkerCount < 2) {
+    return { isTimeline: false, reasons: [`too-few-strong-markers(${stats.strongMarkerCount})`] };
+  }
+  return {
+    isTimeline: true,
+    timeline,
+    reasons: [
+      `tracks(${stats.axisLines})`,
+      `events(${stats.markerCount + stats.pointerCount})`,
+      explicit ? "explicit" : "strong-markers"
+    ]
+  };
+}
+function isAsciiTimelineFence(node) {
+  if (node.type !== "code") return false;
+  if (!isEligibleAsciiTimelineFenceLang(node.lang)) return false;
+  return detectAsciiTimeline(node.value, { explicit: isExplicitTimelineLang(node.lang) }).isTimeline;
+}
+
+// src/doc/treeview/chars.ts
+var RAIL_CHARS = /* @__PURE__ */ new Set(["\u2502", "\u2503", "\u254E", "\u254F", "\u2551", "|"]);
+var BRANCH_TEE = /* @__PURE__ */ new Set(["\u251C", "\u2523", "\u2520", "\u251D", "\u2560", "\u255E"]);
+var BRANCH_ELBOW = /* @__PURE__ */ new Set(["\u2514", "\u2517", "\u2570", "\u255A", "\u2558"]);
+var DASH_CHARS = /* @__PURE__ */ new Set(["\u2500", "\u2501", "\u2550", "-"]);
+function isRailChar(ch) {
+  return RAIL_CHARS.has(ch);
+}
+function isBranchTee(ch) {
+  return BRANCH_TEE.has(ch);
+}
+function isBranchElbow(ch) {
+  return BRANCH_ELBOW.has(ch);
+}
+function isDashChar(ch) {
+  return DASH_CHARS.has(ch);
+}
+function isUnicodeTreeChar(ch) {
+  return BRANCH_TEE.has(ch) || BRANCH_ELBOW.has(ch) || ch === "\u2502" || ch === "\u2503" || ch === "\u2500" || ch === "\u2501";
+}
+function isAsciiTreeChar(ch) {
+  return ch === "|" || ch === "`" || ch === "+" || ch === "-";
+}
+var UNICODE_TREE_VOCAB = {
+  tee: "\u251C\u2500\u2500 ",
+  elbow: "\u2514\u2500\u2500 ",
+  rail: "\u2502   ",
+  gap: "    "
+};
+var ASCII_TREE_VOCAB = {
+  tee: "|-- ",
+  elbow: "`-- ",
+  rail: "|   ",
+  gap: "    "
+};
+
+// src/doc/treeview/parse.ts
+function parseTree(text) {
+  return parseTreeWithStats(text).tree;
+}
+function parseTreeWithStats(text) {
+  const warnings = [];
+  const rawLines = text.replace(/\r\n?/g, "\n").split("\n");
+  const style = detectStyle3(rawLines);
+  const stats = {
+    contentLines: 0,
+    connectorLines: 0,
+    looseLines: 0,
+    indentLevels: 0
+  };
+  const indentSet = /* @__PURE__ */ new Set();
+  const analyzed = [];
+  for (const raw of rawLines) {
+    if (raw.trim().length === 0) continue;
+    stats.contentLines++;
+    const a = analyzeLine(raw);
+    if (!a || a.label.length === 0) {
+      stats.looseLines++;
+      continue;
+    }
+    if (a.hadConnector) stats.connectorLines++;
+    indentSet.add(a.indent);
+    analyzed.push(a);
+  }
+  stats.indentLevels = indentSet.size;
+  const roots = [];
+  const stack = [];
+  for (const a of analyzed) {
+    const node = {
+      id: "",
+      label: a.label,
+      children: [],
+      ...a.comment ? { comment: a.comment } : {}
+    };
+    while (stack.length > 0 && stack[stack.length - 1].indent >= a.indent) stack.pop();
+    if (stack.length === 0) {
+      roots.push(node);
+    } else {
+      stack[stack.length - 1].node.children.push(node);
+    }
+    stack.push({ indent: a.indent, node });
+  }
+  const usedIds = /* @__PURE__ */ new Map();
+  const finalize = (node) => {
+    node.isDir = node.label.endsWith("/") || node.children.length > 0;
+    const base = slugify2(stripTrailingSlash(node.label));
+    const count = usedIds.get(base) ?? 0;
+    usedIds.set(base, count + 1);
+    node.id = count === 0 ? base : `${base}-${count + 1}`;
+    for (const child of node.children) finalize(child);
+  };
+  for (const root of roots) finalize(root);
+  if (analyzed.length > 0 && stats.looseLines > 0) {
+    warnings.push(`loose-lines(${stats.looseLines})`);
+  }
+  return { tree: { roots, style, warnings }, stats };
+}
+function analyzeLine(line) {
+  const chars = Array.from(line);
+  let i = 0;
+  let hadConnector = false;
+  for (; ; ) {
+    while (i < chars.length && (chars[i] === " " || chars[i] === "	")) i++;
+    const ch2 = chars[i];
+    if (ch2 === void 0) return null;
+    if (isRailChar(ch2) && !isDashChar(chars[i + 1] ?? "")) {
+      i++;
+      continue;
+    }
+    break;
+  }
+  const ch = chars[i];
+  if (ch !== void 0) {
+    if (isBranchTee(ch) || isBranchElbow(ch)) {
+      i++;
+      while (i < chars.length && (isDashChar(chars[i]) || isRailChar(chars[i]))) i++;
+      hadConnector = true;
+    } else if ((ch === "|" || ch === "`" || ch === "+") && isDashChar(chars[i + 1] ?? "")) {
+      i++;
+      while (i < chars.length && isDashChar(chars[i])) i++;
+      hadConnector = true;
+    } else if ((ch === "-" || ch === "*" || ch === "+") && (chars[i + 1] ?? "") === " ") {
+      i++;
+      hadConnector = false;
+    }
+  }
+  while (i < chars.length && (chars[i] === " " || chars[i] === "	")) i++;
+  const indent = i;
+  let label = chars.slice(i).join("").replace(/\s+$/u, "");
+  if (label.length === 0) return null;
+  let comment;
+  const commentMatch = /\s+(?:#|<--|\/\/)\s?(.*)$/.exec(label);
+  if (commentMatch) {
+    comment = commentMatch[1].trim() || void 0;
+    label = label.slice(0, commentMatch.index).replace(/\s+$/u, "");
+  }
+  if (label.length === 0) return null;
+  return { indent, label, hadConnector, ...comment ? { comment } : {} };
+}
+function detectStyle3(lines) {
+  let unicode = 0;
+  let ascii = 0;
+  for (const line of lines) {
+    for (const ch of line) {
+      if (isUnicodeTreeChar(ch)) unicode++;
+      else if (isAsciiTreeChar(ch)) ascii++;
+    }
+  }
+  return ascii > unicode ? "ascii" : "unicode";
+}
+function stripTrailingSlash(s) {
+  return s.endsWith("/") ? s.slice(0, -1) : s;
+}
+function slugify2(s) {
+  const slug2 = s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug2 || "node";
+}
+
+// src/doc/treeview/detect.ts
+var TREE_FENCE_LANGS = /* @__PURE__ */ new Set([
+  "text",
+  "txt",
+  "plaintext",
+  "plain",
+  "ascii",
+  "tree"
+]);
+var MAX_LINES3 = 400;
+var MIN_LINES2 = 2;
+var MIN_CONNECTOR_LINES = 2;
+var MIN_NODES = 2;
+var BOX_CORNER_RE = /[┌┐┘┏┓┛╔╗╝╭╮╯]/u;
+function isEligibleTreeFenceLang(lang) {
+  if (lang === null || lang === void 0) return true;
+  const normalized = lang.trim().toLowerCase();
+  return normalized === "" || TREE_FENCE_LANGS.has(normalized);
+}
+function isExplicitTreeLang(lang) {
+  return typeof lang === "string" && lang.trim().toLowerCase() === "tree";
+}
+function detectTree(text, opts = {}) {
+  const explicit = opts.explicit === true;
+  const lines = text.replace(/\r\n?/g, "\n").split("\n");
+  const nonBlank = lines.filter((l) => l.trim().length > 0);
+  const minLines = explicit ? 1 : MIN_LINES2;
+  if (nonBlank.length < minLines) {
+    return { isTree: false, reasons: [`too-few-lines(${nonBlank.length})`] };
+  }
+  if (lines.length > MAX_LINES3) {
+    return { isTree: false, reasons: [`too-many-lines(${lines.length})`] };
+  }
+  const pipeRows = nonBlank.filter((l) => /^\s*\|.*\|\s*$/.test(l)).length;
+  const hasGfmSeparator = nonBlank.some((l) => /^\s*\|?[\s:|-]+\|?\s*$/.test(l) && l.includes("-"));
+  if (pipeRows > nonBlank.length / 2 && hasGfmSeparator) {
+    return { isTree: false, reasons: ["markdown-table"] };
+  }
+  if (BOX_CORNER_RE.test(text)) {
+    return { isTree: false, reasons: ["has-box-corners"] };
+  }
+  if (!explicit && detectAsciiTimeline(text).isTimeline) {
+    return { isTree: false, reasons: ["is-timeline"] };
+  }
+  const boxes = parseAsciiDiagramWithStats(text).diagram.nodes.length;
+  if (boxes >= 2) {
+    return { isTree: false, reasons: [`has-boxes(${boxes})`] };
+  }
+  const { tree, stats } = parseTreeWithStats(text);
+  const nodeCount = countNodes(tree.roots);
+  const minNodes = explicit ? 1 : MIN_NODES;
+  if (nodeCount < minNodes) {
+    return { isTree: false, reasons: [`too-few-nodes(${nodeCount})`] };
+  }
+  if (!explicit) {
+    if (stats.connectorLines < MIN_CONNECTOR_LINES) {
+      return { isTree: false, reasons: [`too-few-connectors(${stats.connectorLines})`] };
+    }
+    if (stats.looseLines > stats.contentLines * 0.25) {
+      return { isTree: false, reasons: [`loose-ratio(${stats.looseLines}/${stats.contentLines})`] };
+    }
+  }
+  return {
+    isTree: true,
+    tree,
+    reasons: [`nodes(${nodeCount})`, explicit ? "explicit" : `connectors(${stats.connectorLines})`]
+  };
+}
+function isTreeFence(node) {
+  if (node.type !== "code") return false;
+  if (!isEligibleTreeFenceLang(node.lang)) return false;
+  return detectTree(node.value, { explicit: isExplicitTreeLang(node.lang) }).isTree;
+}
+function countNodes(nodes) {
+  let n = 0;
+  for (const node of nodes) n += 1 + countNodes(node.children);
+  return n;
+}
+
+// src/recommend/numberHighlight.ts
+var NUMBER_HIGHLIGHT_RE = /(?:[$€£¥]\s?\d+(?:[.,]\d+)*(?:\s?(?:[MBK]|million|billion|thousand))?|\d+(?:[.,]\d+)*\s?(?:%|‰|x|×|[MBK]|million|billion|thousand|percent|years?|days?|hours?)|\d{3,}(?:[.,]\d+)*)/i;
+function matchNumberHighlight(text) {
+  const match = NUMBER_HIGHLIGHT_RE.exec(text);
+  if (!match || match.index === void 0) return null;
+  return {
+    value: match[0],
+    index: match.index,
+    end: match.index + match[0].length
+  };
+}
+
+// src/recommend/templates.ts
+var EMPTY_PROFILE = Object.freeze({
+  hasImage: false,
+  imageCount: 0,
+  hasVideo: false,
+  hasBlockquote: false,
+  hasList: false,
+  hasTable: false,
+  hasDate: false,
+  hasNumberHighlight: false,
+  wordCount: 0
+});
+var DATE_PATTERNS = [
+  /\b(January|February|March|April|May|June|July|August|September|October|November|December)\s+(\d{1,2},?\s+)?\d{4}\b/i,
+  /\b\d{1,2}\s+(January|February|March|April|May|June|July|August|September|October|November|December)\s+\d{4}\b/i,
+  /\b(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Sept|Oct|Nov|Dec)\.?\s+\d{1,2},?\s+\d{4}\b/i,
+  /\b\d{4}-\d{2}-\d{2}\b/,
+  /\b\d{1,2}\/\d{1,2}\/\d{2,4}\b/,
+  /\bQ[1-4]\s+\d{4}\b/,
+  /\b\d{4}s\b/,
+  /\b\d{1,2}(st|nd|rd|th)\s+century\b/i
+];
+var VIDEO_HOST_RE = /(youtube\.com|youtu\.be|vimeo\.com|wistia\.|loom\.com)/i;
+function htmlElementsByTag(root, tagNames) {
+  const blocks = findNodesByType(root, "htmlBlock");
+  const inline = findNodesByType(root, "htmlInline");
+  const out = [];
+  const visit = (n) => {
+    if (n.type === "htmlElement") {
+      if (tagNames.has(n.tagName.toLowerCase())) out.push(n);
+      for (const c of n.children) visit(c);
+    }
+  };
+  for (const b of blocks) for (const c of b.htmlChildren) visit(c);
+  for (const i of inline) {
+    if (Array.isArray(i.htmlChildren)) for (const c of i.htmlChildren) visit(c);
+  }
+  return out;
+}
+function profileBlockContents(nodes) {
+  if (!nodes || nodes.length === 0) return { ...EMPTY_PROFILE };
+  let imageCount = 0;
+  let hasBlockquote = false;
+  let hasList = false;
+  let hasTable = false;
+  const plainParts = [];
+  for (const node of nodes) {
+    imageCount += findNodesByType(node, "image").length;
+    imageCount += findNodesByType(node, "imageReference").length;
+    if (findNodesByType(node, "blockquote").length > 0) hasBlockquote = true;
+    if (findNodesByType(node, "list").length > 0) hasList = true;
+    if (findNodesByType(node, "table").length > 0) hasTable = true;
+    plainParts.push(extractPlainText(node));
+  }
+  const root = { type: "document", children: nodes };
+  const imgTags = htmlElementsByTag(root, /* @__PURE__ */ new Set(["img"]));
+  imageCount += imgTags.length;
+  const videoTags = htmlElementsByTag(root, /* @__PURE__ */ new Set(["video", "iframe", "source"]));
+  let hasVideo = false;
+  for (const el of videoTags) {
+    if (el.tagName.toLowerCase() === "video") {
+      hasVideo = true;
+      break;
+    }
+    const src = el.attributes.src || el.attributes.href || "";
+    if (VIDEO_HOST_RE.test(src)) {
+      hasVideo = true;
+      break;
+    }
+  }
+  if (!hasVideo) {
+    const links = findNodesByType(root, "link");
+    for (const link of links) {
+      if (link.url && VIDEO_HOST_RE.test(link.url)) {
+        hasVideo = true;
+        break;
+      }
+    }
+  }
+  const plainText = plainParts.join(" ").trim();
+  const wordCount = plainText ? plainText.split(/\s+/).length : 0;
+  let hasDate = false;
+  for (const re of DATE_PATTERNS) {
+    if (re.test(plainText)) {
+      hasDate = true;
+      break;
+    }
+  }
+  let hasNumberHighlight = false;
+  walkMarkdownTree(root, (n) => {
+    if (hasNumberHighlight) return true;
+    if (n.type !== "paragraph") return;
+    const text = extractPlainText(n).trim();
+    if (!text) return true;
+    const m = matchNumberHighlight(text);
+    if (!m) return true;
+    const words = text.split(/\s+/).length;
+    if (words <= 8) hasNumberHighlight = true;
+    return true;
+  });
+  let hasAsciiDiagram = false;
+  const codeNodes = [];
+  for (const node of nodes) codeNodes.push(...findNodesByType(node, "code"));
+  if (codeNodes.length === 1 && isEligibleAsciiFenceLang(codeNodes[0].lang) && !hasTable && imageCount === 0 && !hasVideo) {
+    const nonCodeChars = Math.max(0, plainText.length - codeNodes[0].value.length);
+    const explicit = isExplicitDiagramLang(codeNodes[0].lang);
+    if (nonCodeChars <= 400 && detectAsciiDiagram(codeNodes[0].value, { explicit }).isDiagram) {
+      hasAsciiDiagram = true;
+    }
+  }
+  let hasTimeline = false;
+  if (!hasAsciiDiagram && codeNodes.length === 1 && isEligibleAsciiTimelineFenceLang(codeNodes[0].lang) && !hasTable && imageCount === 0 && !hasVideo) {
+    const nonCodeChars = Math.max(0, plainText.length - codeNodes[0].value.length);
+    const explicit = isExplicitTimelineLang(codeNodes[0].lang);
+    if (nonCodeChars <= 400 && detectAsciiTimeline(codeNodes[0].value, { explicit }).isTimeline) {
+      hasTimeline = true;
+    }
+  }
+  let hasTree = false;
+  if (!hasAsciiDiagram && !hasTimeline && codeNodes.length === 1 && isEligibleTreeFenceLang(codeNodes[0].lang) && !hasTable && imageCount === 0 && !hasVideo) {
+    const nonCodeChars = Math.max(0, plainText.length - codeNodes[0].value.length);
+    const explicit = isExplicitTreeLang(codeNodes[0].lang);
+    if (nonCodeChars <= 400 && detectTree(codeNodes[0].value, { explicit }).isTree) {
+      hasTree = true;
+    }
+  }
+  return {
+    hasImage: imageCount > 0,
+    imageCount,
+    hasVideo,
+    hasBlockquote,
+    hasList,
+    hasTable,
+    hasDate,
+    hasNumberHighlight,
+    wordCount,
+    hasAsciiDiagram,
+    hasTimeline,
+    hasTree
+  };
+}
+var UNIVERSAL_DEFAULTS = ["title", "sectionHeader", "factCard", "twoColumn"];
+function recommendedNamesForProfile(profile) {
+  const names = /* @__PURE__ */ new Set();
+  let anyContentSignal = false;
+  if (profile.hasAsciiDiagram) {
+    anyContentSignal = true;
+    names.add("diagram");
+  }
+  if (profile.hasTimeline) {
+    anyContentSignal = true;
+    names.add("timeline");
+  }
+  if (profile.hasTree) {
+    anyContentSignal = true;
+    names.add("tree");
+  }
+  if (profile.hasImage) {
+    anyContentSignal = true;
+    names.add("imageWithCaption");
+    names.add("leftFeature");
+    names.add("rightFeature");
+    if (profile.imageCount >= 2) names.add("photoGrid");
+  }
+  if (profile.hasVideo) {
+    anyContentSignal = true;
+    names.add("videoWithCaption");
+    if (profile.hasBlockquote) names.add("videoPullQuote");
+  }
+  if (profile.hasBlockquote) {
+    anyContentSignal = true;
+    names.add("quote");
+    names.add("pullQuote");
+    names.add("fullBleedQuote");
+  }
+  if (profile.hasList) {
+    anyContentSignal = true;
+    names.add("list");
+  }
+  if (profile.hasTable) {
+    anyContentSignal = true;
+    names.add("dataTable");
+    names.add("comparisonBar");
+  }
+  if (profile.hasDate) {
+    anyContentSignal = true;
+    names.add("dateEvent");
+  }
+  if (profile.hasNumberHighlight) {
+    anyContentSignal = true;
+    names.add("statHighlight");
+  }
+  if (anyContentSignal) {
+    names.add("title");
+    names.add("sectionHeader");
+  } else {
+    for (const n of UNIVERSAL_DEFAULTS) names.add(n);
+  }
+  return Array.from(names);
+}
+function pickAutoTemplate(profile, blockIndex = 0) {
+  if (profile.hasAsciiDiagram) return "diagram";
+  if (profile.hasTimeline) return "timeline";
+  if (profile.hasTree) return "tree";
+  if (profile.hasTable) return "dataTable";
+  if (profile.imageCount >= 2) return "photoGrid";
+  if (profile.hasImage) return blockIndex % 2 === 0 ? "leftFeature" : "rightFeature";
+  if (profile.hasBlockquote) return "quote";
+  if (profile.hasNumberHighlight) return "statHighlight";
+  if (profile.hasList) return "list";
+  return void 0;
+}
+function recommendTemplatesForBlock(profile, allNames) {
+  const desired = new Set(recommendedNamesForProfile(profile));
+  const recommended = [];
+  const rest = [];
+  for (const name of allNames) {
+    if (desired.has(name)) recommended.push(name);
+    else rest.push(name);
+  }
+  return { recommended, rest };
+}
+
+export {
+  matchNumberHighlight,
+  isHoriz,
+  isVert,
+  isJunction,
+  arrowDirection,
+  UNICODE_VOCAB,
+  ASCII_VOCAB,
+  parseAsciiDiagram,
+  traceBoxes,
+  toGrid,
+  ASCII_DIAGRAM_FENCE_LANGS,
+  isEligibleAsciiFenceLang,
+  isExplicitDiagramLang,
+  detectAsciiDiagram,
+  isAsciiDiagramFence,
+  parseWrappedFlowTimeline,
+  isWrappedFlowTimelineSource,
+  parseAsciiTimeline,
+  parseAsciiTimelineWithStats,
+  ASCII_TIMELINE_FENCE_LANGS,
+  isEligibleAsciiTimelineFenceLang,
+  isExplicitTimelineLang,
+  detectAsciiTimeline,
+  isAsciiTimelineFence,
+  UNICODE_TREE_VOCAB,
+  ASCII_TREE_VOCAB,
+  parseTree,
+  TREE_FENCE_LANGS,
+  isEligibleTreeFenceLang,
+  isExplicitTreeLang,
+  detectTree,
+  isTreeFence,
+  profileBlockContents,
+  pickAutoTemplate,
+  recommendTemplatesForBlock
+};
+//# sourceMappingURL=chunk-5UYI3RJB.js.map