slackmark 0.1.0

package/dist/index.js

@@ -0,0 +1,3402 @@
+// src/capabilities/capabilities.ts
+var CapabilityPresetName = {
+  Latest: "latest",
+  Conservative: "conservative",
+  D2025_02: "2025-02",
+  D2025_08: "2025-08",
+  D2026_03: "2026-03",
+  D2026_05: "2026-05",
+  D2026_06: "2026-06"
+};
+var ALL_OFF = {
+  richText: false,
+  markdownBlock: false,
+  tableBlock: false,
+  preformattedLanguage: false,
+  headerLevel: false,
+  dataTable: false,
+  dataVisualization: false,
+  containerBlock: false
+};
+var CONSERVATIVE = {
+  ...ALL_OFF,
+  richText: true
+};
+var P_2025_02 = {
+  ...CONSERVATIVE,
+  markdownBlock: true
+};
+var P_2025_08 = {
+  ...P_2025_02,
+  tableBlock: true
+};
+var P_2026_03 = {
+  ...P_2025_08,
+  preformattedLanguage: true,
+  headerLevel: true
+};
+var P_2026_05 = {
+  ...P_2026_03,
+  dataTable: true
+};
+var P_2026_06 = {
+  ...P_2026_05,
+  dataVisualization: true,
+  containerBlock: true
+};
+var LATEST = { ...P_2026_06 };
+var CAPABILITY_PRESETS = {
+  latest: LATEST,
+  conservative: CONSERVATIVE,
+  "2025-02": P_2025_02,
+  "2025-08": P_2025_08,
+  "2026-03": P_2026_03,
+  "2026-05": P_2026_05,
+  "2026-06": P_2026_06
+};
+function resolveCapabilities(input, overrides) {
+  let base;
+  if (input === void 0) {
+    base = CAPABILITY_PRESETS.latest;
+  } else if (typeof input === "string") {
+    const preset = CAPABILITY_PRESETS[input];
+    if (preset === void 0) {
+      base = CAPABILITY_PRESETS.latest;
+    } else {
+      base = preset;
+    }
+  } else if (isFullFlags(input)) {
+    base = input;
+  } else {
+    base = { ...CAPABILITY_PRESETS.latest, ...input };
+  }
+  if (overrides === void 0) {
+    return Object.freeze({ ...base });
+  }
+  return Object.freeze({ ...base, ...overrides });
+}
+function isFullFlags(value) {
+  return typeof value.richText === "boolean" && typeof value.markdownBlock === "boolean" && typeof value.tableBlock === "boolean" && typeof value.preformattedLanguage === "boolean" && typeof value.headerLevel === "boolean" && typeof value.dataTable === "boolean" && typeof value.dataVisualization === "boolean" && typeof value.containerBlock === "boolean";
+}
+
+// src/constants.ts
+var MAX_BLOCKS_PER_MESSAGE = 50;
+var SECTION_TEXT_MAX_CHARS = 3e3;
+var HEADER_TEXT_MAX_CHARS = 150;
+var HEADER_LEVEL_MAX = 4;
+var IMAGE_URL_MAX_CHARS = 3e3;
+var IMAGE_ALT_MAX_CHARS = 2e3;
+var CONTEXT_ELEMENTS_MAX = 10;
+var MARKDOWN_CUMULATIVE_MAX_CHARS = 12e3;
+var TABLE_MAX_ROWS = 100;
+var TABLE_MAX_COLS = 20;
+var TABLE_CELL_CHARS_MAX = 1e4;
+var TABLE_PREFERRED_MAX_ROWS = 50;
+var DATA_TABLE_MAX_DATA_ROWS = 200;
+var DATA_TABLE_CELL_CHARS_MAX = 2e4;
+var CHART_TITLE_MAX_CHARS = 50;
+var CHART_LABEL_MAX_CHARS = 20;
+var CHART_SEGMENTS_MAX = 12;
+var CHART_SERIES_MAX = 12;
+var CHART_POINTS_MAX = 20;
+var DATA_VISUALIZATION_MAX_PER_MESSAGE = 2;
+var MESSAGE_TEXT_SAFETY_MAX_CHARS = 4e4;
+var RICH_TEXT_LIST_INDENT_MAX = 6;
+var CONTAINER_CHILDREN_MAX = 10;
+var CONTAINER_TITLE_MAX_CHARS = 150;
+var TABLE_CELL_WRAP_THRESHOLD = 40;
+var ELLIPSIS = "\u2026";
+
+// src/budget/standard-budget-ledger.ts
+var StandardBudgetLedger = class {
+  maxBlocks;
+  enforceChartCap;
+  blocks;
+  tableChars;
+  dataTableChars;
+  markdownChars;
+  charts;
+  totalChars;
+  constructor(maxBlocks = MAX_BLOCKS_PER_MESSAGE, options) {
+    this.maxBlocks = maxBlocks;
+    this.enforceChartCap = options?.enforceChartCap ?? true;
+    this.blocks = 0;
+    this.tableChars = 0;
+    this.dataTableChars = 0;
+    this.markdownChars = 0;
+    this.charts = 0;
+    this.totalChars = 0;
+  }
+  tryReserveBlocks(count) {
+    if (this.blocks + count > this.maxBlocks) {
+      return false;
+    }
+    this.blocks += count;
+    return true;
+  }
+  tryReserveTableChars(chars) {
+    if (this.tableChars + chars > TABLE_CELL_CHARS_MAX) {
+      return false;
+    }
+    this.tableChars += chars;
+    return true;
+  }
+  tryReserveDataTableChars(chars) {
+    if (this.dataTableChars + chars > DATA_TABLE_CELL_CHARS_MAX) {
+      return false;
+    }
+    this.dataTableChars += chars;
+    return true;
+  }
+  tryReserveMarkdownChars(chars) {
+    if (this.markdownChars + chars > MARKDOWN_CUMULATIVE_MAX_CHARS) {
+      return false;
+    }
+    this.markdownChars += chars;
+    return true;
+  }
+  tryReserveChart() {
+    if (this.enforceChartCap && this.charts + 1 > DATA_VISUALIZATION_MAX_PER_MESSAGE) {
+      return false;
+    }
+    this.charts += 1;
+    return true;
+  }
+  tryReserveTotalChars(chars) {
+    if (this.totalChars + chars > MESSAGE_TEXT_SAFETY_MAX_CHARS) {
+      return false;
+    }
+    this.totalChars += chars;
+    return true;
+  }
+  tryReserveClaim(claim) {
+    if (claim === void 0) {
+      return true;
+    }
+    const nextBlocks = this.blocks + (claim.blocks ?? 0);
+    const nextTable = this.tableChars + (claim.tableChars ?? 0);
+    const nextData = this.dataTableChars + (claim.dataTableChars ?? 0);
+    const nextMd = this.markdownChars + (claim.markdownChars ?? 0);
+    const nextCharts = this.charts + (claim.chart === true ? 1 : 0);
+    const nextTotal = this.totalChars + (claim.totalChars ?? 0);
+    if (nextBlocks > this.maxBlocks) return false;
+    if (nextTable > TABLE_CELL_CHARS_MAX) return false;
+    if (nextData > DATA_TABLE_CELL_CHARS_MAX) return false;
+    if (nextMd > MARKDOWN_CUMULATIVE_MAX_CHARS) return false;
+    if (this.enforceChartCap && nextCharts > DATA_VISUALIZATION_MAX_PER_MESSAGE) return false;
+    if (nextTotal > MESSAGE_TEXT_SAFETY_MAX_CHARS) return false;
+    this.blocks = nextBlocks;
+    this.tableChars = nextTable;
+    this.dataTableChars = nextData;
+    this.markdownChars = nextMd;
+    this.charts = nextCharts;
+    this.totalChars = nextTotal;
+    return true;
+  }
+  remainingBlocks() {
+    return this.maxBlocks - this.blocks;
+  }
+  snapshot() {
+    return {
+      blocks: this.blocks,
+      tableChars: this.tableChars,
+      dataTableChars: this.dataTableChars,
+      markdownChars: this.markdownChars,
+      charts: this.charts,
+      totalChars: this.totalChars
+    };
+  }
+  restore(snapshot) {
+    this.blocks = snapshot.blocks;
+    this.tableChars = snapshot.tableChars;
+    this.dataTableChars = snapshot.dataTableChars;
+    this.markdownChars = snapshot.markdownChars;
+    this.charts = snapshot.charts;
+    this.totalChars = snapshot.totalChars;
+  }
+  resetForNewMessage() {
+    this.blocks = 0;
+    this.tableChars = 0;
+    this.dataTableChars = 0;
+    this.markdownChars = 0;
+    this.charts = 0;
+    this.totalChars = 0;
+  }
+};
+
+// src/budget/recording-degradation-collector.ts
+var RecordingDegradationCollector = class {
+  items;
+  constructor() {
+    this.items = [];
+  }
+  add(d) {
+    this.items.push(d);
+  }
+  all() {
+    return this.items.slice();
+  }
+};
+
+// src/budget/conversion-context.ts
+var ConversionContext = class _ConversionContext {
+  config;
+  budget;
+  degradations;
+  definitions;
+  footnotes;
+  footnoteOrder;
+  precedingHeading;
+  path;
+  constructor(deps) {
+    this.config = deps.config;
+    this.budget = deps.budget;
+    this.degradations = deps.degradations;
+    this.definitions = deps.definitions;
+    this.footnotes = deps.footnotes;
+    this.footnoteOrder = deps.footnoteOrder;
+    this.precedingHeading = deps.precedingHeading;
+    this.path = deps.path;
+  }
+  withPath(segment) {
+    return new _ConversionContext({
+      config: this.config,
+      budget: this.budget,
+      degradations: this.degradations,
+      definitions: this.definitions,
+      footnotes: this.footnotes,
+      footnoteOrder: this.footnoteOrder,
+      precedingHeading: this.precedingHeading,
+      path: this.path.length === 0 ? segment : `${this.path}/${segment}`
+    });
+  }
+  withPrecedingHeading(heading) {
+    return new _ConversionContext({
+      config: this.config,
+      budget: this.budget,
+      degradations: this.degradations,
+      definitions: this.definitions,
+      footnotes: this.footnotes,
+      footnoteOrder: this.footnoteOrder,
+      precedingHeading: heading,
+      path: this.path
+    });
+  }
+  withDegradations(degradations) {
+    return new _ConversionContext({
+      config: this.config,
+      budget: this.budget,
+      degradations,
+      definitions: this.definitions,
+      footnotes: this.footnotes,
+      footnoteOrder: this.footnoteOrder,
+      precedingHeading: this.precedingHeading,
+      path: this.path
+    });
+  }
+};
+
+// src/registry/adapter-registry.ts
+var AdapterRegistry = class {
+  adapters;
+  constructor(adapters) {
+    this.adapters = adapters;
+  }
+  async emit(node, ctx) {
+    for (const adapter of this.adapters) {
+      if (!adapter.match(node, ctx)) {
+        continue;
+      }
+      const candidates = adapter.plan(node, ctx);
+      let budgetBlocked = false;
+      let emittedEmpty = false;
+      for (const candidate of candidates) {
+        if (!capabilitiesAllow(candidate.requires, ctx)) {
+          continue;
+        }
+        const beforeClaim = ctx.budget.snapshot();
+        if (!ctx.budget.tryReserveClaim(candidate.budget)) {
+          budgetBlocked = true;
+          continue;
+        }
+        const blocks = await candidate.emit(ctx);
+        if (blocks.length === 0) {
+          ctx.budget.restore(beforeClaim);
+          emittedEmpty = true;
+          continue;
+        }
+        return blocks;
+      }
+      if (emittedEmpty && !budgetBlocked) {
+        return [];
+      }
+      ctx.degradations.add({
+        nodeType: node.type,
+        from: "adapter",
+        to: "empty",
+        reason: budgetBlocked ? "Message budget exhausted (blocks/chars/charts); content omitted" : "All candidates failed capability/budget gates",
+        path: ctx.path
+      });
+      return [];
+    }
+    ctx.degradations.add({
+      nodeType: node.type,
+      from: node.type,
+      to: "skip",
+      reason: "No adapter matched node",
+      path: ctx.path
+    });
+    return [];
+  }
+};
+function capabilitiesAllow(requires, ctx) {
+  if (requires === void 0) {
+    return true;
+  }
+  for (const flag of requires) {
+    if (!ctx.config.capabilities[flag]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/assert-never.ts
+function assertNever(value, message) {
+  const detail = message ?? "Unexpected value";
+  throw new Error(`${detail}: ${JSON.stringify(value)}`);
+}
+
+// src/types.ts
+var OverflowMode = {
+  Degrade: "degrade",
+  Split: "split"
+};
+var ConversionStrategy = {
+  RichTextFirst: "rich-text-first",
+  MarkdownBlock: "markdown-block"
+};
+
+// src/assemble/message-assembler.ts
+var MessageAssembler = class {
+  plainText;
+  constructor(deps) {
+    this.plainText = deps.plainText;
+  }
+  assemble(blocks, ctx, footnoteBlocks) {
+    const coalesced = coalesceRichText(blocks);
+    if (ctx.config.overflow === OverflowMode.Split) {
+      return this.splitMessages([...coalesced, ...footnoteBlocks], ctx);
+    }
+    const noteCount = footnoteBlocks.length;
+    const bodyCap = Math.max(0, MAX_BLOCKS_PER_MESSAGE - noteCount);
+    const clippedBody = coalesced.slice(0, bodyCap);
+    if (coalesced.length > bodyCap) {
+      ctx.degradations.add({
+        nodeType: "message",
+        from: `${String(coalesced.length)} body blocks`,
+        to: `${String(bodyCap)} body blocks`,
+        reason: noteCount > 0 ? `overflow=degrade truncated body to reserve ${String(noteCount)} footnote blocks` : "overflow=degrade truncated to 50 blocks",
+        path: ctx.path
+      });
+    }
+    let notes = footnoteBlocks;
+    if (notes.length > MAX_BLOCKS_PER_MESSAGE) {
+      notes = footnoteBlocks.slice(0, MAX_BLOCKS_PER_MESSAGE);
+      ctx.degradations.add({
+        nodeType: "footnote",
+        from: `${String(footnoteBlocks.length)} footnote blocks`,
+        to: `${String(MAX_BLOCKS_PER_MESSAGE)} footnote blocks`,
+        reason: "Footnote blocks alone exceed 50; truncated",
+        path: ctx.path
+      });
+    }
+    const finalBlocks = [...clippedBody, ...notes];
+    return [this.toMessage(finalBlocks, ctx)];
+  }
+  splitMessages(blocks, ctx) {
+    const messages = [];
+    let current = [];
+    let ledger = new StandardBudgetLedger(MAX_BLOCKS_PER_MESSAGE);
+    const flush = () => {
+      if (current.length === 0) {
+        return;
+      }
+      messages.push(this.toMessage(current, ctx));
+      current = [];
+      ledger = new StandardBudgetLedger(MAX_BLOCKS_PER_MESSAGE);
+    };
+    for (const block of blocks) {
+      const claim = claimForBlock(block);
+      if (!ledger.tryReserveClaim(claim)) {
+        flush();
+        if (!ledger.tryReserveClaim(claim)) {
+          ctx.degradations.add({
+            nodeType: "message",
+            from: block.type,
+            to: "omitted",
+            reason: "Block exceeds per-message budget; omitted",
+            path: ctx.path
+          });
+          continue;
+        }
+      }
+      current.push(block);
+    }
+    flush();
+    if (messages.length > 1) {
+      ctx.degradations.add({
+        nodeType: "message",
+        from: "single",
+        to: `${String(messages.length)} messages`,
+        reason: "Split at semantic block boundaries (per-message budgets)",
+        path: ctx.path
+      });
+    }
+    return messages.length > 0 ? messages : [{ blocks: [], text: " " }];
+  }
+  toMessage(blocks, ctx) {
+    const raw = this.plainText.renderFromBlocks(blocks);
+    if (raw.length <= MESSAGE_TEXT_SAFETY_MAX_CHARS) {
+      return { blocks, text: raw };
+    }
+    ctx.degradations.add({
+      nodeType: "message",
+      from: `${String(raw.length)} text chars`,
+      to: `${String(MESSAGE_TEXT_SAFETY_MAX_CHARS)} text chars`,
+      reason: "Notification text truncated to 40k safety limit",
+      path: ctx.path
+    });
+    return { blocks, text: raw.slice(0, MESSAGE_TEXT_SAFETY_MAX_CHARS) };
+  }
+};
+function buildFootnoteBlocks(entries, degradations) {
+  if (entries.length === 0) {
+    return [];
+  }
+  const blocks = [{ type: "divider" }];
+  const elements = [];
+  for (const e of entries) {
+    const note = `[${String(e.n)}] ${e.text}`;
+    if (note.length > SECTION_TEXT_MAX_CHARS) {
+      degradations?.add({
+        nodeType: "footnote",
+        from: `${String(note.length)} chars`,
+        to: `${String(SECTION_TEXT_MAX_CHARS)} chars`,
+        reason: "Footnote context text truncated to 3000 chars",
+        path: "footnote"
+      });
+      elements.push({ type: "mrkdwn", text: note.slice(0, SECTION_TEXT_MAX_CHARS) });
+    } else {
+      elements.push({ type: "mrkdwn", text: note });
+    }
+  }
+  for (let i = 0; i < elements.length; i += CONTEXT_ELEMENTS_MAX) {
+    const chunk = elements.slice(i, i + CONTEXT_ELEMENTS_MAX);
+    blocks.push({ type: "context", elements: chunk });
+  }
+  return blocks;
+}
+function claimForBlock(block) {
+  switch (block.type) {
+    case "data_visualization":
+      return { blocks: 1, chart: true };
+    case "markdown":
+      return { blocks: 1, markdownChars: block.text.length };
+    case "table":
+      return { blocks: 1, tableChars: countEmittedTableChars(block) };
+    case "data_table":
+      return { blocks: 1, dataTableChars: countEmittedTableChars(block) };
+    case "rich_text":
+    case "header":
+    case "divider":
+    case "section":
+    case "image":
+    case "context":
+    case "container":
+      return { blocks: 1 };
+    default:
+      return assertNever(block);
+  }
+}
+function countEmittedTableChars(block) {
+  let total = 0;
+  for (const row of block.rows) {
+    for (const cell of row) {
+      total += cellTextLength(cell);
+    }
+  }
+  return total;
+}
+function cellTextLength(cell) {
+  if (cell.type === "raw_text" || cell.type === "raw_number") {
+    return cell.text.length;
+  }
+  return JSON.stringify(cell).length;
+}
+function coalesceRichText(blocks) {
+  const out = [];
+  let pending;
+  const flushPending = () => {
+    if (pending === void 0 || pending.length === 0) {
+      pending = void 0;
+      return;
+    }
+    const block = { type: "rich_text", elements: pending };
+    out.push(block);
+    pending = void 0;
+  };
+  for (const block of blocks) {
+    if (block.type === "rich_text" && isCoalescable(block)) {
+      if (pending === void 0) {
+        pending = [...block.elements];
+      } else {
+        pending.push(...block.elements);
+      }
+    } else {
+      flushPending();
+      out.push(block);
+    }
+  }
+  flushPending();
+  return out;
+}
+function isCoalescable(block) {
+  return block.elements.every((e) => e.type === "rich_text_section");
+}
+
+// src/assemble/text-fallback.ts
+var DeterministicPlainTextRenderer = class {
+  render(markdown) {
+    const parts = [];
+    let i = 0;
+    const src = markdown;
+    while (i < src.length) {
+      if (src.startsWith("```", i)) {
+        const end = src.indexOf("```", i + 3);
+        if (end === -1) {
+          parts.push(src.slice(i + 3));
+          break;
+        }
+        parts.push(src.slice(i + 3, end).trim());
+        i = end + 3;
+        continue;
+      }
+      parts.push(src[i] ?? "");
+      i += 1;
+    }
+    const raw = parts.join("").replace(/!\[[^\]]{0,200}\]\([^)]{0,3000}\)/g, " ").replace(/\[([^\]]{0,200})\]\([^)]{0,3000}\)/g, "$1").replace(/[#>*_`~]/g, "").replace(/\s+/g, " ").trim();
+    return raw.length > 0 ? raw : " ";
+  }
+  renderFromBlocks(blocks) {
+    const parts = [];
+    for (const block of blocks) {
+      switch (block.type) {
+        case "header":
+          parts.push(block.text.text);
+          break;
+        case "section":
+          if (block.text !== void 0) {
+            parts.push(stripMrkdwn(block.text.text));
+          }
+          break;
+        case "rich_text":
+          parts.push(richTextToPlain(block.elements));
+          break;
+        case "markdown":
+          parts.push(this.render(block.text));
+          break;
+        case "divider":
+          parts.push("---");
+          break;
+        case "image":
+          parts.push(block.alt_text);
+          break;
+        case "context":
+          for (const el of block.elements) {
+            if (el.type === "mrkdwn" || el.type === "plain_text") {
+              parts.push(stripMrkdwn(el.text));
+            }
+          }
+          break;
+        case "table":
+        case "data_table":
+          parts.push(tableToPlain(block.rows));
+          break;
+        case "data_visualization":
+          parts.push(block.title);
+          break;
+        case "container":
+          if (block.title !== void 0) {
+            parts.push(block.title.text);
+          }
+          parts.push(this.renderFromBlocks(block.child_blocks));
+          break;
+        default:
+          break;
+      }
+    }
+    const text = parts.map((p) => p.trim()).filter((p) => p.length > 0).join("\n").trim();
+    return text.length > 0 ? text : " ";
+  }
+};
+function stripMrkdwn(text) {
+  return text.replace(/<([^|>]{1,3000})\|([^>]{0,500})>/g, "$2").replace(/<([^>]{1,3000})>/g, "$1").replace(/[*_~`]/g, "");
+}
+function richTextToPlain(elements) {
+  const parts = [];
+  for (const el of elements) {
+    switch (el.type) {
+      case "rich_text_section":
+      case "rich_text_quote":
+        parts.push(inlinesToPlain(el.elements));
+        break;
+      case "rich_text_list":
+        for (const item of el.elements) {
+          parts.push(`\u2022 ${inlinesToPlain(item.elements)}`);
+        }
+        break;
+      case "rich_text_preformatted":
+        parts.push(inlinesToPlain(el.elements));
+        break;
+      default:
+        break;
+    }
+  }
+  return parts.join("\n");
+}
+function inlinesToPlain(elements) {
+  const parts = [];
+  for (const el of elements) {
+    switch (el.type) {
+      case "text":
+        parts.push(el.text);
+        break;
+      case "link":
+        parts.push(el.text ?? el.url);
+        break;
+      case "emoji":
+        parts.push(`:${el.name}:`);
+        break;
+      case "user":
+        parts.push(`@${el.user_id}`);
+        break;
+      case "channel":
+        parts.push(`#${el.channel_id}`);
+        break;
+      default:
+        break;
+    }
+  }
+  return parts.join("");
+}
+function tableToPlain(rows) {
+  const lines = [];
+  for (const row of rows) {
+    const cells = row.map((cell) => cellPlain(cell));
+    lines.push(cells.join(" | "));
+  }
+  return lines.join("\n");
+}
+function cellPlain(cell) {
+  if (typeof cell !== "object" || cell === null) {
+    return "";
+  }
+  const c = cell;
+  if (c.type === "raw_text" && typeof c.text === "string") {
+    return c.text;
+  }
+  if (c.type === "raw_number") {
+    return typeof c.text === "string" ? c.text : String(c.value ?? "");
+  }
+  if (c.type === "rich_text" && Array.isArray(c.elements)) {
+    return richTextToPlain(c.elements);
+  }
+  return "";
+}
+
+// src/parsers/remark-markdown-parser.ts
+import remarkFrontmatter from "remark-frontmatter";
+import remarkGfm from "remark-gfm";
+import remarkMath from "remark-math";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+var RemarkMarkdownParser = class {
+  async parse(markdown, options) {
+    const processor = unified().use(remarkParse).use(remarkGfm);
+    if (options.enableFrontmatter) {
+      processor.use(remarkFrontmatter, ["yaml", "toml"]);
+    }
+    if (options.enableMath) {
+      processor.use(remarkMath);
+    }
+    return processor.parse(markdown);
+  }
+};
+
+// src/mermaid/mermaid-pie-parser.ts
+var COMMENT_RE = /%%[^\n]{0,500}/g;
+var TITLE_RE = /^\s*pie\b(?:\s+showData)?(?:\s+title\s+(.+))?\s*$/i;
+var SHOW_DATA_RE = /\bshowData\b/i;
+var ENTRY_RE = /^\s*"([^"]{1,200})"\s*:\s*(-?\d+(?:\.\d+)?)\s*$/;
+var MermaidPieParser = class {
+  diagramType;
+  constructor() {
+    this.diagramType = "pie";
+  }
+  parse(source) {
+    const cleaned = source.replace(COMMENT_RE, "");
+    const lines = cleaned.split(/\r?\n/);
+    let title;
+    let showData = false;
+    const segments = [];
+    let seenHeader = false;
+    for (const raw of lines) {
+      const line = raw.trim();
+      if (line.length === 0) {
+        continue;
+      }
+      if (!seenHeader) {
+        if (!/^\s*pie\b/i.test(line)) {
+          return { ok: false, reason: "Not a pie diagram" };
+        }
+        seenHeader = true;
+        showData = SHOW_DATA_RE.test(line);
+        const tm = TITLE_RE.exec(line);
+        const titlePart = tm?.[1]?.trim();
+        if (titlePart !== void 0 && titlePart.length > 0) {
+          title = titlePart;
+        }
+        continue;
+      }
+      const titleLine = /^\s*title\s+(.+)\s*$/i.exec(line);
+      if (titleLine !== null && title === void 0) {
+        title = (titleLine[1] ?? "").trim();
+        continue;
+      }
+      const em = ENTRY_RE.exec(line);
+      if (em === null) {
+        return { ok: false, reason: `Invalid pie entry: ${line}` };
+      }
+      const label = em[1] ?? "";
+      const value = Number(em[2]);
+      if (!(value > 0)) {
+        return { ok: false, reason: `Pie values must be > 0 (got ${String(value)})` };
+      }
+      segments.push({ label, value });
+    }
+    if (!seenHeader) {
+      return { ok: false, reason: "Missing pie header" };
+    }
+    if (segments.length === 0) {
+      return { ok: false, reason: "Pie has no segments" };
+    }
+    const ast = {
+      kind: "pie",
+      title,
+      showData,
+      segments
+    };
+    return { ok: true, value: ast };
+  }
+};
+
+// src/mermaid/mermaid-xychart-parser.ts
+var COMMENT_RE2 = /%%[^\n]{0,500}/g;
+var NUM = String.raw`-?\d+(?:\.\d+)?`;
+var NUM_LIST_RE = new RegExp(String.raw`\[\s*((?:${NUM}\s*,\s*)*${NUM})\s*\]`);
+var STR_LIST_RE = /\[\s*((?:"[^"]{0,200}"\s*,\s*)*"[^"]{0,200}")\s*\]/;
+var MermaidXyChartParser = class {
+  diagramType;
+  constructor() {
+    this.diagramType = "xychart-beta";
+  }
+  parse(source) {
+    const cleaned = source.replace(COMMENT_RE2, "");
+    const lines = cleaned.split(/\r?\n/);
+    let title;
+    let categories = [];
+    let xLabel;
+    let yLabel;
+    let yMin;
+    let yMax;
+    const bars = [];
+    const linesSeries = [];
+    let seenHeader = false;
+    for (const raw of lines) {
+      const line = raw.trim();
+      if (line.length === 0) {
+        continue;
+      }
+      if (!seenHeader) {
+        if (!/^\s*xychart-beta\b/i.test(line)) {
+          return { ok: false, reason: "Not an xychart-beta diagram" };
+        }
+        seenHeader = true;
+        continue;
+      }
+      const titleM = /^\s*title\s+"([^"]{0,200})"\s*$/i.exec(line) ?? /^\s*title\s+(.+)\s*$/i.exec(line);
+      if (titleM !== null) {
+        title = (titleM[1] ?? "").trim();
+        continue;
+      }
+      if (/^\s*x-axis\b/i.test(line)) {
+        const strList = STR_LIST_RE.exec(line);
+        if (strList !== null) {
+          categories = parseStringList(strList[1] ?? "");
+          const labelM = /^\s*x-axis\s+"([^"]{0,200})"\s+/i.exec(line);
+          if (labelM !== null) {
+            xLabel = labelM[1];
+          }
+          continue;
+        }
+        const rangeM = new RegExp(
+          String.raw`x-axis\s+(?:"([^"]{0,200})"\s+)?(${NUM})\s*-->\s*(${NUM})`,
+          "i"
+        ).exec(line);
+        if (rangeM !== null) {
+          xLabel = rangeM[1];
+          const min = Number(rangeM[2]);
+          const max = Number(rangeM[3]);
+          if (!Number.isFinite(min) || !Number.isFinite(max) || max < min) {
+            return { ok: false, reason: `Invalid x-axis range: ${line}` };
+          }
+          const span = max - min + 1;
+          if (span > CHART_POINTS_MAX) {
+            return {
+              ok: false,
+              reason: `x-axis range has ${String(span)} points (max ${String(CHART_POINTS_MAX)})`
+            };
+          }
+          categories = [];
+          for (let i = min; i <= max; i += 1) {
+            categories.push(String(i));
+          }
+          continue;
+        }
+        return { ok: false, reason: `Invalid x-axis: ${line}` };
+      }
+      if (/^\s*y-axis\b/i.test(line)) {
+        const ym = new RegExp(
+          String.raw`y-axis\s+(?:"([^"]{0,200})"\s+)?(?:(${NUM})\s*-->\s*(${NUM}))?`,
+          "i"
+        ).exec(line);
+        if (ym !== null) {
+          yLabel = ym[1];
+          if (ym[2] !== void 0 && ym[3] !== void 0) {
+            yMin = Number(ym[2]);
+            yMax = Number(ym[3]);
+          }
+          continue;
+        }
+        return { ok: false, reason: `Invalid y-axis: ${line}` };
+      }
+      if (/^\s*bar\b/i.test(line)) {
+        const nums = NUM_LIST_RE.exec(line);
+        if (nums === null) {
+          return { ok: false, reason: `Invalid bar series: ${line}` };
+        }
+        bars.push(parseNumberList(nums[1] ?? ""));
+        continue;
+      }
+      if (/^\s*line\b/i.test(line)) {
+        const nums = NUM_LIST_RE.exec(line);
+        if (nums === null) {
+          return { ok: false, reason: `Invalid line series: ${line}` };
+        }
+        linesSeries.push(parseNumberList(nums[1] ?? ""));
+        continue;
+      }
+      return { ok: false, reason: `Unrecognized xychart line: ${line}` };
+    }
+    if (!seenHeader) {
+      return { ok: false, reason: "Missing xychart-beta header" };
+    }
+    if (categories.length === 0) {
+      return { ok: false, reason: "xychart missing categories" };
+    }
+    if (bars.length === 0 && linesSeries.length === 0) {
+      return { ok: false, reason: "xychart has no series" };
+    }
+    const ast = {
+      kind: "xychart-beta",
+      title,
+      categories,
+      xLabel,
+      yLabel,
+      yMin,
+      yMax,
+      bars,
+      lines: linesSeries
+    };
+    return { ok: true, value: ast };
+  }
+};
+function parseStringList(inner) {
+  const out = [];
+  const re = /"([^"]{0,200})"/g;
+  let m = re.exec(inner);
+  while (m !== null) {
+    out.push(m[1] ?? "");
+    m = re.exec(inner);
+  }
+  return out;
+}
+function parseNumberList(inner) {
+  return inner.split(",").map((s) => s.trim()).filter((s) => s.length > 0).map((s) => Number(s));
+}
+
+// src/converter/slackmark-converter.ts
+import { toString } from "mdast-util-to-string";
+
+// src/errors.ts
+var ConfigurationError = class extends Error {
+  name;
+  constructor(message, options) {
+    super(message, options?.cause !== void 0 ? { cause: options.cause } : void 0);
+    this.name = "ConfigurationError";
+  }
+};
+
+// src/converter/resolve-config.ts
+function resolveConfig(defaults, overrides) {
+  const merged = {
+    ...defaults,
+    ...overrides,
+    capabilityOverrides: {
+      ...defaults.capabilityOverrides,
+      ...overrides?.capabilityOverrides
+    },
+    renderers: overrides?.renderers ?? defaults.renderers,
+    uploader: overrides?.uploader ?? defaults.uploader,
+    mentionResolvers: overrides?.mentionResolvers ?? defaults.mentionResolvers
+  };
+  const capabilities = resolveCapabilities(merged.capabilities, merged.capabilityOverrides);
+  const overflow = merged.overflow ?? OverflowMode.Degrade;
+  if (overflow !== OverflowMode.Degrade && overflow !== OverflowMode.Split) {
+    throw new ConfigurationError(
+      `Invalid overflow mode ${JSON.stringify(overflow)}; use "degrade" or "split".`
+    );
+  }
+  const strategy = merged.strategy ?? ConversionStrategy.RichTextFirst;
+  if (strategy !== ConversionStrategy.RichTextFirst && strategy !== ConversionStrategy.MarkdownBlock) {
+    throw new ConfigurationError(
+      `Invalid strategy ${JSON.stringify(strategy)}; use "rich-text-first" or "markdown-block".`
+    );
+  }
+  const renderers = merged.renderers ?? [];
+  return Object.freeze({
+    capabilities,
+    overflow,
+    strategy,
+    renderers,
+    uploader: merged.uploader,
+    enableMath: merged.enableMath === true,
+    enableFrontmatter: merged.enableFrontmatter === true,
+    mentionResolvers: merged.mentionResolvers
+  });
+}
+
+// src/converter/slackmark-converter.ts
+var SlackMarkConverter = class {
+  parser;
+  registry;
+  assembler;
+  plainText;
+  defaultOptions;
+  constructor(deps) {
+    this.parser = deps.parser;
+    this.registry = deps.registry;
+    this.assembler = deps.assembler;
+    this.plainText = deps.plainText;
+    this.defaultOptions = deps.defaultOptions;
+  }
+  /**
+   * Convert markdown to a single message. Always uses overflow=degrade so content
+   * is truncated with degradations rather than silently dropping split messages.
+   * Callers that need multi-message output should use {@link convertToMessages}.
+   */
+  async convert(markdown, options) {
+    const multi = await this.convertToMessages(markdown, {
+      ...options,
+      overflow: OverflowMode.Degrade
+    });
+    const first = multi.messages[0] ?? { blocks: [], text: " " };
+    return {
+      blocks: first.blocks,
+      text: first.text,
+      degradations: multi.degradations
+    };
+  }
+  /**
+   * Convert markdown into one or more messages at semantic boundaries.
+   */
+  async convertToMessages(markdown, options) {
+    const config = resolveConfig(this.defaultOptions, options);
+    const degradations = new RecordingDegradationCollector();
+    const splitting = config.overflow === OverflowMode.Split;
+    const budget = new StandardBudgetLedger(
+      splitting ? Number.MAX_SAFE_INTEGER : MAX_BLOCKS_PER_MESSAGE,
+      { enforceChartCap: !splitting }
+    );
+    try {
+      if (config.strategy === ConversionStrategy.MarkdownBlock) {
+        return this.emitAsMarkdownBlocks(markdown, config, degradations, budget);
+      }
+      const tree = await this.parser.parse(markdown, {
+        enableMath: config.enableMath,
+        enableFrontmatter: config.enableFrontmatter
+      });
+      const { definitions, footnotes, footnoteOrder } = collectRefs(tree);
+      let precedingHeading;
+      const emitted = [];
+      let index = 0;
+      for (const node of tree.children) {
+        if (splitting) {
+          budget.resetForNewMessage();
+        }
+        const ctx = new ConversionContext({
+          config,
+          budget,
+          degradations,
+          definitions,
+          footnotes,
+          footnoteOrder,
+          precedingHeading,
+          path: `root[${String(index)}]`
+        });
+        if (node.type === "heading") {
+          precedingHeading = toString(node);
+        }
+        const blocks = await this.registry.emit(node, ctx);
+        emitted.push(...blocks);
+        index += 1;
+      }
+      const footnoteEntries = footnoteOrder.map((id, i) => {
+        const def = footnotes.get(id);
+        return {
+          n: i + 1,
+          text: def !== void 0 ? toString(def).trim() : id
+        };
+      });
+      const footnoteBlocks = buildFootnoteBlocks(footnoteEntries, degradations);
+      const assembleCtx = new ConversionContext({
+        config,
+        budget,
+        degradations,
+        definitions,
+        footnotes,
+        footnoteOrder,
+        precedingHeading,
+        path: "assemble"
+      });
+      const messages = this.assembler.assemble(emitted, assembleCtx, footnoteBlocks);
+      return {
+        messages,
+        degradations: degradations.all()
+      };
+    } catch (err) {
+      degradations.add({
+        nodeType: "document",
+        from: "convert",
+        to: "section",
+        reason: err instanceof Error ? err.message : "Unknown conversion error",
+        path: "root"
+      });
+      const text = safeNotificationText(this.plainText, markdown, degradations);
+      return {
+        messages: [
+          {
+            blocks: [
+              {
+                type: "section",
+                text: { type: "mrkdwn", text: clampSectionFallback(text, degradations) }
+              }
+            ],
+            text
+          }
+        ],
+        degradations: degradations.all()
+      };
+    }
+  }
+  emitAsMarkdownBlocks(markdown, config, degradations, budget) {
+    const chunks = chunkMarkdown(markdown, 12e3);
+    let blocks = [];
+    if (!config.capabilities.markdownBlock) {
+      degradations.add({
+        nodeType: "document",
+        from: "markdown-block",
+        to: "section",
+        reason: "markdownBlock capability off; emitting section fallback",
+        path: "root"
+      });
+      const text = safeNotificationText(this.plainText, markdown, degradations);
+      blocks = [
+        {
+          type: "section",
+          text: { type: "mrkdwn", text: clampSectionFallback(text, degradations) }
+        }
+      ];
+    } else {
+      for (const chunk of chunks) {
+        if (config.overflow === OverflowMode.Split) {
+          budget.resetForNewMessage();
+        }
+        if (!budget.tryReserveClaim({ blocks: 1, markdownChars: chunk.length })) {
+          degradations.add({
+            nodeType: "document",
+            from: "markdown-block",
+            to: "truncated",
+            reason: "markdown 12k cumulative budget exhausted",
+            path: "root"
+          });
+          break;
+        }
+        blocks.push({ type: "markdown", text: chunk });
+      }
+    }
+    const assembleCtx = new ConversionContext({
+      config,
+      budget,
+      degradations,
+      definitions: /* @__PURE__ */ new Map(),
+      footnotes: /* @__PURE__ */ new Map(),
+      footnoteOrder: [],
+      precedingHeading: void 0,
+      path: "assemble"
+    });
+    const messages = this.assembler.assemble(blocks, assembleCtx, []);
+    return {
+      messages,
+      degradations: degradations.all()
+    };
+  }
+};
+function safeNotificationText(plainText, markdown, degradations) {
+  const raw = plainText.render(markdown);
+  if (raw.length <= MESSAGE_TEXT_SAFETY_MAX_CHARS) {
+    return raw;
+  }
+  degradations.add({
+    nodeType: "message",
+    from: `${String(raw.length)} text chars`,
+    to: `${String(MESSAGE_TEXT_SAFETY_MAX_CHARS)} text chars`,
+    reason: "Notification text truncated to 40k safety limit",
+    path: "root"
+  });
+  return raw.slice(0, MESSAGE_TEXT_SAFETY_MAX_CHARS);
+}
+function clampSectionFallback(text, degradations) {
+  if (text.length <= SECTION_TEXT_MAX_CHARS) {
+    return text;
+  }
+  degradations.add({
+    nodeType: "section",
+    from: `${String(text.length)} chars`,
+    to: `${String(SECTION_TEXT_MAX_CHARS)} chars`,
+    reason: "Section text truncated to 3000 chars",
+    path: "root"
+  });
+  return text.slice(0, SECTION_TEXT_MAX_CHARS);
+}
+function collectRefs(tree) {
+  const definitions = /* @__PURE__ */ new Map();
+  const footnotes = /* @__PURE__ */ new Map();
+  for (const node of tree.children) {
+    if (node.type === "definition") {
+      definitions.set(node.identifier.toLowerCase(), node);
+    }
+    if (node.type === "footnoteDefinition") {
+      footnotes.set(node.identifier, node);
+    }
+  }
+  const footnoteOrder = [];
+  const seen = /* @__PURE__ */ new Set();
+  walkFootnoteReferences(tree, (id) => {
+    if (!seen.has(id)) {
+      seen.add(id);
+      footnoteOrder.push(id);
+    }
+  });
+  return { definitions, footnotes, footnoteOrder };
+}
+function walkFootnoteReferences(node, onRef) {
+  if (node === null || typeof node !== "object") {
+    return;
+  }
+  const record = node;
+  if (record.type === "footnoteDefinition") {
+    return;
+  }
+  if (record.type === "footnoteReference" && typeof record.identifier === "string") {
+    onRef(record.identifier);
+    return;
+  }
+  if (record.children !== void 0) {
+    for (const child of record.children) {
+      walkFootnoteReferences(child, onRef);
+    }
+  }
+}
+function chunkMarkdown(text, max) {
+  if (text.length <= max) {
+    return [text.length > 0 ? text : " "];
+  }
+  const out = [];
+  for (let i = 0; i < text.length; i += max) {
+    out.push(text.slice(i, i + max));
+  }
+  return out;
+}
+
+// src/adapters/blockquote-adapter.ts
+import { toString as toString3 } from "mdast-util-to-string";
+
+// src/adapters/inline.ts
+import { toString as toString2 } from "mdast-util-to-string";
+var EMOJI_SHORTCODE_RE = /:([a-z0-9_+-]{1,64}):/g;
+var KNOWN_SLACK_EMOJI = /* @__PURE__ */ new Set([
+  "smile",
+  "grinning",
+  "wink",
+  "blush",
+  "wave",
+  "thumbsup",
+  "thumbsdown",
+  "tada",
+  "rocket",
+  "fire",
+  "heart",
+  "eyes",
+  "thinking_face",
+  "sweat_smile",
+  "joy",
+  "sob",
+  "clap",
+  "100",
+  "white_check_mark",
+  "x",
+  "warning",
+  "bulb",
+  "memo",
+  "mag",
+  "link",
+  "gear",
+  "bug",
+  "sparkles",
+  "+1",
+  "-1",
+  "ok_hand",
+  "pray",
+  "star",
+  "zap",
+  "check",
+  "heavy_check_mark"
+]);
+var HTTP_URL_RE = /^(https?:|mailto:)/i;
+var IMAGE_EXT_RE = /\.(png|jpe?g|gif)(?:\?|#|$)/i;
+function emitPhrasing(nodes, ctx, baseStyle = {}) {
+  const elements = [];
+  const hoistedImages = [];
+  let pendingAnchor;
+  const flushPendingAnchor = () => {
+    if (pendingAnchor === void 0) {
+      return;
+    }
+    const label = pendingAnchor.textParts.join("");
+    elements.push({
+      type: "link",
+      url: pendingAnchor.href,
+      text: label.length > 0 ? label : pendingAnchor.href,
+      style: styleOrUndefined(pendingAnchor.style)
+    });
+    pendingAnchor = void 0;
+  };
+  for (const node of nodes) {
+    if (pendingAnchor !== void 0) {
+      if (node.type === "html" && /^<\/a\s*>$/i.test(node.value.trim())) {
+        flushPendingAnchor();
+        continue;
+      }
+      if (node.type === "text") {
+        pendingAnchor.textParts.push(node.value);
+        continue;
+      }
+      if (node.type === "break") {
+        pendingAnchor.textParts.push("\n");
+        continue;
+      }
+      pendingAnchor.textParts.push(toString2(node));
+      continue;
+    }
+    if (node.type === "html") {
+      const trimmed = node.value.trim();
+      const openOnly = /^<a\b([^>]{0,500})>\s*$/i.exec(trimmed);
+      if (openOnly !== null) {
+        const hrefMatch = /href\s*=\s*["']([^"']{0,3000})["']/i.exec(openOnly[1] ?? "");
+        const href = hrefMatch?.[1];
+        if (href !== void 0 && isValidLinkUrl(href)) {
+          pendingAnchor = { href, style: baseStyle, textParts: [] };
+          continue;
+        }
+      }
+      elements.push(...emitInlineHtml(node.value, baseStyle, ctx));
+      continue;
+    }
+    switch (node.type) {
+      case "text": {
+        elements.push(...emitTextWithMentionsAndEmoji(node, baseStyle, ctx));
+        break;
+      }
+      case "strong": {
+        const inner = emitPhrasing(node.children, ctx, { ...baseStyle, bold: true });
+        elements.push(...inner.elements);
+        hoistedImages.push(...inner.hoistedImages);
+        break;
+      }
+      case "emphasis": {
+        const inner = emitPhrasing(node.children, ctx, {
+          ...baseStyle,
+          italic: true
+        });
+        elements.push(...inner.elements);
+        hoistedImages.push(...inner.hoistedImages);
+        break;
+      }
+      case "delete": {
+        const inner = emitPhrasing(node.children, ctx, { ...baseStyle, strike: true });
+        elements.push(...inner.elements);
+        hoistedImages.push(...inner.hoistedImages);
+        break;
+      }
+      case "inlineCode": {
+        const el = {
+          type: "text",
+          text: node.value,
+          style: styleOrUndefined({ ...baseStyle, code: true })
+        };
+        elements.push(el);
+        break;
+      }
+      case "break": {
+        elements.push({ type: "text", text: "\n", style: styleOrUndefined(baseStyle) });
+        break;
+      }
+      case "link": {
+        elements.push(...emitLink(node, ctx, baseStyle));
+        break;
+      }
+      case "linkReference": {
+        elements.push(...emitLinkReference(node, ctx, baseStyle));
+        break;
+      }
+      case "image": {
+        const url = node.url;
+        if (isPublicImageUrl(url)) {
+          hoistedImages.push({
+            url,
+            alt: node.alt ?? "",
+            title: node.title ?? void 0
+          });
+          elements.push({
+            type: "link",
+            url,
+            text: node.alt && node.alt.length > 0 ? node.alt : url,
+            style: styleOrUndefined(baseStyle)
+          });
+        } else {
+          ctx.degradations.add({
+            nodeType: "image",
+            from: "image",
+            to: "link",
+            reason: "Image URL is not a public http(s) png/jpg/gif \u22643000 chars",
+            path: ctx.path
+          });
+          elements.push({
+            type: "link",
+            url: url.length > 0 ? url : "#",
+            text: node.alt && node.alt.length > 0 ? node.alt : url,
+            style: styleOrUndefined(baseStyle)
+          });
+        }
+        break;
+      }
+      case "imageReference": {
+        const def = ctx.definitions.get(node.identifier.toLowerCase());
+        if (def === void 0) {
+          elements.push({
+            type: "text",
+            text: node.alt ?? node.identifier,
+            style: styleOrUndefined(baseStyle)
+          });
+          break;
+        }
+        const asImage = emitPhrasing(
+          [
+            {
+              type: "image",
+              url: def.url,
+              alt: node.alt ?? void 0,
+              title: def.title ?? void 0
+            }
+          ],
+          ctx,
+          baseStyle
+        );
+        elements.push(...asImage.elements);
+        hoistedImages.push(...asImage.hoistedImages);
+        break;
+      }
+      case "footnoteReference": {
+        const idx = ctx.footnoteOrder.indexOf(node.identifier);
+        const n = idx >= 0 ? idx + 1 : 1;
+        elements.push({
+          type: "text",
+          text: `[${String(n)}]`,
+          style: styleOrUndefined(baseStyle)
+        });
+        break;
+      }
+      case "inlineMath": {
+        elements.push({
+          type: "text",
+          text: node.value,
+          style: styleOrUndefined({ ...baseStyle, code: true })
+        });
+        ctx.degradations.add({
+          nodeType: "inlineMath",
+          from: "inlineMath",
+          to: "style.code",
+          reason: "Math rendering not configured; emitted as inline code",
+          path: ctx.path
+        });
+        break;
+      }
+      default: {
+        const text = toString2(node);
+        if (text.length > 0) {
+          elements.push({ type: "text", text, style: styleOrUndefined(baseStyle) });
+        }
+        break;
+      }
+    }
+  }
+  flushPendingAnchor();
+  return { elements: coalesceText(elements), hoistedImages };
+}
+function phrasingToPlain(nodes) {
+  return toString2({ type: "paragraph", children: nodes });
+}
+function isPublicImageUrl(url) {
+  if (url.length === 0 || url.length > IMAGE_URL_MAX_CHARS) {
+    return false;
+  }
+  if (!HTTP_URL_RE.test(url)) {
+    return false;
+  }
+  if (/^https?:\/\/(localhost|127\.0\.0\.1|0\.0\.0\.0|10\.|192\.168\.|172\.(1[6-9]|2\d|3[01])\.)/i.test(
+    url
+  )) {
+    return false;
+  }
+  return IMAGE_EXT_RE.test(url);
+}
+function countHoistableImages(nodes, ctx) {
+  let count = 0;
+  for (const node of nodes) {
+    switch (node.type) {
+      case "image": {
+        if (isPublicImageUrl(node.url)) {
+          count += 1;
+        }
+        break;
+      }
+      case "imageReference": {
+        const def = ctx.definitions.get(node.identifier.toLowerCase());
+        if (def !== void 0 && isPublicImageUrl(def.url)) {
+          count += 1;
+        }
+        break;
+      }
+      case "strong":
+      case "emphasis":
+      case "delete": {
+        count += countHoistableImages(node.children, ctx);
+        break;
+      }
+      case "text":
+      case "inlineCode":
+      case "break":
+      case "link":
+      case "linkReference":
+      case "footnoteReference":
+      case "html":
+      case "inlineMath":
+        break;
+      default: {
+        break;
+      }
+    }
+  }
+  return count;
+}
+function truncateLabel(label, max) {
+  if (label.length <= max) {
+    return { text: label, truncated: false };
+  }
+  return { text: `${label.slice(0, Math.max(0, max - 1))}${ELLIPSIS}`, truncated: true };
+}
+function hoistedImageBlock(h, ctx) {
+  return {
+    type: "image",
+    image_url: h.url,
+    alt_text: clampImageText(h.alt.length > 0 ? h.alt : "image", ctx, "alt_text"),
+    title: h.title !== void 0 && h.title.length > 0 ? { type: "plain_text", text: clampImageText(h.title, ctx, "title") } : void 0
+  };
+}
+function clampSectionText(text, ctx, nodeType) {
+  if (text.length <= SECTION_TEXT_MAX_CHARS) {
+    return text;
+  }
+  ctx.degradations.add({
+    nodeType,
+    from: `${String(text.length)} chars`,
+    to: `${String(SECTION_TEXT_MAX_CHARS)} chars`,
+    reason: "Section text truncated to 3000 chars",
+    path: ctx.path
+  });
+  return text.slice(0, SECTION_TEXT_MAX_CHARS);
+}
+function preformattedRichText(text, language) {
+  return {
+    type: "rich_text",
+    elements: [
+      {
+        type: "rich_text_preformatted",
+        elements: [{ type: "text", text: text.length > 0 ? text : " " }],
+        border: 0,
+        language
+      }
+    ]
+  };
+}
+function clampImageText(value, ctx, field) {
+  if (value.length <= IMAGE_ALT_MAX_CHARS) {
+    return value;
+  }
+  ctx.degradations.add({
+    nodeType: "image",
+    from: field,
+    to: "truncated",
+    reason: `Image ${field} truncated to ${String(IMAGE_ALT_MAX_CHARS)} chars`,
+    path: ctx.path
+  });
+  return value.slice(0, IMAGE_ALT_MAX_CHARS);
+}
+function styleOrUndefined(style) {
+  if (style.bold === true || style.italic === true || style.strike === true || style.code === true || style.underline === true) {
+    return style;
+  }
+  return void 0;
+}
+var MENTION_RE = /(?<![A-Za-z0-9._-])@([a-zA-Z0-9._-]{1,64})|(?<![A-Za-z0-9_-])#([a-zA-Z0-9_-]{1,80})/g;
+function phrasingNeedsMentionResolution(nodes, ctx) {
+  const resolvers = ctx.config.mentionResolvers;
+  if (resolvers?.resolveUser === void 0 && resolvers?.resolveChannel === void 0) {
+    return false;
+  }
+  const plain = phrasingToPlain(nodes);
+  MENTION_RE.lastIndex = 0;
+  return MENTION_RE.test(plain);
+}
+function emitTextWithMentionsAndEmoji(node, style, ctx) {
+  const resolvers = ctx.config.mentionResolvers;
+  const canUser = resolvers?.resolveUser !== void 0;
+  const canChannel = resolvers?.resolveChannel !== void 0;
+  if (!canUser && !canChannel) {
+    return emitTextWithEmoji(node.value, style);
+  }
+  const value = node.value;
+  const out = [];
+  MENTION_RE.lastIndex = 0;
+  let last = 0;
+  let match = MENTION_RE.exec(value);
+  while (match !== null) {
+    const start = match.index;
+    if (start > last) {
+      out.push(...emitTextWithEmoji(value.slice(last, start), style));
+    }
+    const userHandle = match[1];
+    const channelName = match[2];
+    if (userHandle !== void 0 && canUser) {
+      const userId = resolvers.resolveUser?.(userHandle);
+      if (userId !== void 0 && userId.length > 0) {
+        out.push({ type: "user", user_id: userId, style: styleOrUndefined(style) });
+      } else {
+        out.push(...emitTextWithEmoji(match[0], style));
+      }
+    } else if (channelName !== void 0 && canChannel) {
+      const channelId = resolvers.resolveChannel?.(channelName);
+      if (channelId !== void 0 && channelId.length > 0) {
+        out.push({ type: "channel", channel_id: channelId, style: styleOrUndefined(style) });
+      } else {
+        out.push(...emitTextWithEmoji(match[0], style));
+      }
+    } else {
+      out.push(...emitTextWithEmoji(match[0], style));
+    }
+    last = start + match[0].length;
+    match = MENTION_RE.exec(value);
+  }
+  if (last < value.length) {
+    out.push(...emitTextWithEmoji(value.slice(last), style));
+  }
+  if (out.length === 0) {
+    out.push(...emitTextWithEmoji(value, style));
+  }
+  return out;
+}
+function emitTextWithEmoji(value, style) {
+  const out = [];
+  EMOJI_SHORTCODE_RE.lastIndex = 0;
+  let last = 0;
+  let match = EMOJI_SHORTCODE_RE.exec(value);
+  while (match !== null) {
+    const start = match.index;
+    if (start > last) {
+      out.push({ type: "text", text: value.slice(last, start), style: styleOrUndefined(style) });
+    }
+    const name = match[1] ?? "";
+    if (KNOWN_SLACK_EMOJI.has(name)) {
+      const emoji = { type: "emoji", name };
+      out.push(emoji);
+    } else {
+      out.push({ type: "text", text: match[0], style: styleOrUndefined(style) });
+    }
+    last = start + match[0].length;
+    match = EMOJI_SHORTCODE_RE.exec(value);
+  }
+  if (last < value.length) {
+    out.push({ type: "text", text: value.slice(last), style: styleOrUndefined(style) });
+  }
+  if (out.length === 0) {
+    out.push({ type: "text", text: value, style: styleOrUndefined(style) });
+  }
+  return out;
+}
+function emitLink(node, ctx, style) {
+  const url = node.url;
+  const text = phrasingToPlain(node.children);
+  if (!isValidLinkUrl(url)) {
+    ctx.degradations.add({
+      nodeType: "link",
+      from: "link",
+      to: "text",
+      reason: "Invalid or oversized URL",
+      path: ctx.path
+    });
+    const suffix = url.length > 0 ? ` (${url})` : "";
+    return [{ type: "text", text: `${text}${suffix}`, style: styleOrUndefined(style) }];
+  }
+  const link = {
+    type: "link",
+    url,
+    text: text.length > 0 ? text : url,
+    style: styleOrUndefined(style)
+  };
+  return [link];
+}
+function emitLinkReference(node, ctx, style) {
+  const def = ctx.definitions.get(node.identifier.toLowerCase());
+  if (def === void 0) {
+    return [
+      {
+        type: "text",
+        text: phrasingToPlain(node.children) || node.identifier,
+        style: styleOrUndefined(style)
+      }
+    ];
+  }
+  return emitLink(
+    {
+      type: "link",
+      url: def.url,
+      title: def.title ?? void 0,
+      children: node.children
+    },
+    ctx,
+    style
+  );
+}
+function isValidLinkUrl(url) {
+  if (url.length === 0 || url.length > IMAGE_URL_MAX_CHARS) {
+    return false;
+  }
+  return HTTP_URL_RE.test(url) || url.startsWith("#") || url.startsWith("/");
+}
+var INLINE_TAG_RE = /<\/?(b|strong|i|em|s|del|code|br|a)(\s+[^>]{0,200})?>|[^<]+/gi;
+function emitInlineHtml(html, style, ctx) {
+  const out = [];
+  const stack = [];
+  let current = style;
+  let openAnchor;
+  INLINE_TAG_RE.lastIndex = 0;
+  let m = INLINE_TAG_RE.exec(html);
+  let matched = false;
+  while (m !== null) {
+    matched = true;
+    const token = m[0];
+    if (token.startsWith("<")) {
+      const tag = (m[1] ?? "").toLowerCase();
+      const closing = token.startsWith("</");
+      if (tag === "br") {
+        if (openAnchor !== void 0) {
+          openAnchor.textParts.push("\n");
+        } else {
+          out.push({ type: "text", text: "\n", style: styleOrUndefined(current) });
+        }
+      } else if (closing) {
+        if (tag === "a" && openAnchor !== void 0) {
+          const label = openAnchor.textParts.join("");
+          out.push({
+            type: "link",
+            url: openAnchor.href,
+            text: label.length > 0 ? label : openAnchor.href,
+            style: styleOrUndefined(openAnchor.style)
+          });
+          openAnchor = void 0;
+        }
+        stack.pop();
+        current = stack.length > 0 ? stack[stack.length - 1]?.style ?? style : style;
+      } else if (tag === "a") {
+        const hrefMatch = /href\s*=\s*["']([^"']{0,3000})["']/i.exec(token);
+        const href = hrefMatch?.[1];
+        stack.push({ tag, style: current });
+        if (href !== void 0 && isValidLinkUrl(href)) {
+          openAnchor = { href, style: current, textParts: [] };
+        }
+      } else {
+        const next = { ...current };
+        if (tag === "b" || tag === "strong") next.bold = true;
+        if (tag === "i" || tag === "em") next.italic = true;
+        if (tag === "s" || tag === "del") next.strike = true;
+        if (tag === "code") next.code = true;
+        stack.push({ tag, style: next });
+        current = next;
+      }
+    } else if (token.length > 0) {
+      if (openAnchor !== void 0) {
+        openAnchor.textParts.push(token);
+      } else {
+        out.push({ type: "text", text: token, style: styleOrUndefined(current) });
+      }
+    }
+    m = INLINE_TAG_RE.exec(html);
+  }
+  if (openAnchor !== void 0) {
+    const label = openAnchor.textParts.join("");
+    out.push({
+      type: "link",
+      url: openAnchor.href,
+      text: label.length > 0 ? label : openAnchor.href,
+      style: styleOrUndefined(openAnchor.style)
+    });
+  }
+  if (!matched) {
+    ctx.degradations.add({
+      nodeType: "html",
+      from: "html",
+      to: "text",
+      reason: "Unrecognized inline HTML stripped to text",
+      path: ctx.path
+    });
+    const stripped = html.replace(/<[^>]{0,200}>/g, "");
+    if (stripped.length > 0) {
+      out.push({ type: "text", text: stripped, style: styleOrUndefined(style) });
+    }
+  }
+  return out;
+}
+function coalesceText(elements) {
+  const out = [];
+  for (const el of elements) {
+    const prev = out[out.length - 1];
+    if (el.type === "text" && prev !== void 0 && prev.type === "text" && JSON.stringify(prev.style) === JSON.stringify(el.style)) {
+      out[out.length - 1] = { type: "text", text: prev.text + el.text, style: prev.style };
+    } else {
+      out.push(el);
+    }
+  }
+  return out;
+}
+
+// src/adapters/blockquote-adapter.ts
+var ADMONITION_RE = /^\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\]\s*/i;
+var ADMONITION_META = {
+  NOTE: { emoji: "\u{1F4DD}", title: "Note" },
+  TIP: { emoji: "\u{1F4A1}", title: "Tip" },
+  IMPORTANT: { emoji: "\u2757", title: "Important" },
+  WARNING: { emoji: "\u26A0\uFE0F", title: "Warning" },
+  CAUTION: { emoji: "\u{1F6AB}", title: "Caution" }
+};
+var BlockquoteAdapter = class {
+  match(node, _ctx) {
+    return node.type === "blockquote";
+  }
+  plan(node, _ctx) {
+    const quote = node;
+    return [
+      {
+        budget: { blocks: 1 },
+        emit: (ctx) => {
+          const elements = flattenQuote(quote, ctx);
+          const block = {
+            type: "rich_text",
+            elements: [{ type: "rich_text_quote", elements, border: 0 }]
+          };
+          return [block];
+        }
+      }
+    ];
+  }
+};
+function flattenQuote(quote, ctx) {
+  const parts = [];
+  let first = true;
+  for (const child of quote.children) {
+    if (child.type === "paragraph") {
+      let children = child.children;
+      if (first && children[0]?.type === "text") {
+        const textNode = children[0];
+        const m = ADMONITION_RE.exec(textNode.value);
+        if (m !== null) {
+          const kind = (m[1] ?? "NOTE").toUpperCase();
+          const meta = ADMONITION_META[kind];
+          parts.push({
+            type: "text",
+            text: `${meta.emoji}${meta.title}
+`,
+            style: { bold: true }
+          });
+          const rest = textNode.value.slice(m[0].length);
+          children = [
+            ...rest.length > 0 ? [{ ...textNode, value: rest }] : [],
+            ...children.slice(1)
+          ];
+        }
+      }
+      first = false;
+      const inline = emitPhrasing(children, ctx);
+      if (parts.length > 0 && inline.elements.length > 0) {
+        parts.push({ type: "text", text: "\n" });
+      }
+      parts.push(...inline.elements);
+    } else if (child.type === "list") {
+      ctx.degradations.add({
+        nodeType: "blockquote",
+        from: "list",
+        to: "bullet_lines",
+        reason: "Nested list inside blockquote flattened",
+        path: ctx.path
+      });
+      if (parts.length > 0) parts.push({ type: "text", text: "\n" });
+      for (const item of child.children) {
+        parts.push({ type: "text", text: `\u2022 ${toString3(item)}
+` });
+      }
+    } else if (child.type === "code") {
+      ctx.degradations.add({
+        nodeType: "blockquote",
+        from: "code",
+        to: "text",
+        reason: "Nested code inside blockquote flattened to text",
+        path: ctx.path
+      });
+      if (parts.length > 0) parts.push({ type: "text", text: "\n" });
+      parts.push({ type: "text", text: child.value, style: { code: true } });
+    } else {
+      ctx.degradations.add({
+        nodeType: "blockquote",
+        from: child.type,
+        to: "text",
+        reason: "Nested block inside blockquote flattened",
+        path: ctx.path
+      });
+      if (parts.length > 0) parts.push({ type: "text", text: "\n" });
+      parts.push({ type: "text", text: toString3(child) });
+    }
+  }
+  return parts.length > 0 ? parts : [{ type: "text", text: " " }];
+}
+
+// src/adapters/code-fence-adapter.ts
+var CodeFenceAdapter = class {
+  match(node, _ctx) {
+    return node.type === "code";
+  }
+  plan(node, _ctx) {
+    const code = node;
+    const hasLang = code.lang !== null && code.lang !== void 0 && code.lang.length > 0;
+    return [
+      {
+        requires: ["preformattedLanguage"],
+        budget: { blocks: 1 },
+        emit: () => [preformatted(code, true)]
+      },
+      {
+        budget: { blocks: 1 },
+        emit: (emitCtx) => {
+          if (hasLang) {
+            emitCtx.degradations.add({
+              nodeType: "code",
+              from: "preformatted.language",
+              to: "preformatted",
+              reason: "preformattedLanguage capability unavailable; omitting language",
+              path: emitCtx.path
+            });
+          }
+          return [preformatted(code, false)];
+        }
+      }
+    ];
+  }
+};
+function preformatted(code, withLang) {
+  const language = withLang && code.lang !== null && code.lang !== void 0 && code.lang.length > 0 ? code.lang.toLowerCase() : void 0;
+  return preformattedRichText(code.value, language);
+}
+
+// src/adapters/heading-adapter.ts
+var HeadingAdapter = class {
+  match(node, _ctx) {
+    return node.type === "heading";
+  }
+  plan(node, ctx) {
+    const heading = node;
+    const hoistCount = countHoistableImages(heading.children, ctx);
+    const needsRich = headingNeedsRichText(heading, ctx);
+    if (!needsRich) {
+      return [
+        {
+          requires: ["headerLevel"],
+          budget: { blocks: 1 },
+          emit: () => {
+            return emitPlainHeader(heading, true);
+          }
+        },
+        {
+          budget: { blocks: 1 },
+          emit: (emitCtx) => {
+            emitCtx.degradations.add({
+              nodeType: "heading",
+              from: "header.level",
+              to: "header",
+              reason: "headerLevel capability unavailable; omitting level",
+              path: emitCtx.path
+            });
+            return emitPlainHeader(heading, false);
+          }
+        }
+      ];
+    }
+    const richCandidates = [
+      {
+        budget: { blocks: 1 + hoistCount },
+        emit: (emitCtx) => {
+          return emitRichHeading(heading, emitCtx, true);
+        }
+      }
+    ];
+    if (hoistCount > 0) {
+      richCandidates.push({
+        budget: { blocks: 1 },
+        emit: (emitCtx) => {
+          emitCtx.degradations.add({
+            nodeType: "heading",
+            from: "rich_text+images",
+            to: "rich_text",
+            reason: "Budget exhausted for hoisted heading images; emitting text only",
+            path: emitCtx.path
+          });
+          return emitRichHeading(heading, emitCtx, false);
+        }
+      });
+    }
+    return richCandidates;
+  }
+};
+function headingNeedsRichText(heading, ctx) {
+  if (heading.depth > HEADER_LEVEL_MAX) {
+    return true;
+  }
+  const plain = phrasingToPlain(heading.children);
+  if (plain.length > HEADER_TEXT_MAX_CHARS) {
+    return true;
+  }
+  if (phrasingNeedsMentionResolution(heading.children, ctx)) {
+    return true;
+  }
+  return heading.children.some(
+    (c) => c.type === "link" || c.type === "inlineCode" || c.type === "strong" || c.type === "emphasis" || c.type === "delete" || c.type === "image" || c.type === "imageReference" || c.type === "html"
+  );
+}
+function emitPlainHeader(heading, withLevel) {
+  const plain = phrasingToPlain(heading.children);
+  const block = {
+    type: "header",
+    text: { type: "plain_text", text: plain.length > 0 ? plain : " " },
+    level: withLevel ? heading.depth : void 0
+  };
+  return [block];
+}
+function emitRichHeading(heading, ctx, hoistImages) {
+  const plain = phrasingToPlain(heading.children);
+  const depth = heading.depth;
+  if (depth > HEADER_LEVEL_MAX) {
+    ctx.degradations.add({
+      nodeType: "heading",
+      from: `header.h${String(depth)}`,
+      to: "rich_text.bold",
+      reason: `Heading level ${String(depth)} exceeds max ${String(HEADER_LEVEL_MAX)}`,
+      path: ctx.path
+    });
+  } else if (plain.length > HEADER_TEXT_MAX_CHARS) {
+    ctx.degradations.add({
+      nodeType: "heading",
+      from: "header",
+      to: "rich_text.bold",
+      reason: "Heading exceeds 150 plain chars",
+      path: ctx.path
+    });
+  } else {
+    ctx.degradations.add({
+      nodeType: "heading",
+      from: "header",
+      to: "rich_text.bold",
+      reason: "Heading contains inline content unsupported by header (styles, links, images, or mentions)",
+      path: ctx.path
+    });
+  }
+  const inline = emitPhrasing(heading.children, ctx, { bold: true });
+  const rich = {
+    type: "rich_text",
+    elements: [
+      {
+        type: "rich_text_section",
+        elements: inline.elements.length > 0 ? inline.elements : [{ type: "text", text: " ", style: { bold: true } }]
+      }
+    ]
+  };
+  const blocks = [rich];
+  if (!hoistImages) {
+    return blocks;
+  }
+  for (const h of inline.hoistedImages) {
+    blocks.push(hoistedImageBlock(h, ctx));
+  }
+  return blocks;
+}
+
+// src/adapters/html-block-adapter.ts
+var DETAILS_RE = /<details\b[^>]{0,200}>\s*<summary\b[^>]{0,200}>([\s\S]{0,500}?)<\/summary>([\s\S]{0,8000}?)<\/details>/i;
+var HtmlBlockAdapter = class {
+  match(node, _ctx) {
+    return node.type === "html";
+  }
+  plan(node, _ctx) {
+    const html = node;
+    const details = DETAILS_RE.exec(html.value);
+    if (details !== null) {
+      const title = stripTags(details[1] ?? "Details").trim();
+      const body = stripTags(details[2] ?? "").trim();
+      return [
+        {
+          requires: ["containerBlock"],
+          budget: { blocks: 1 },
+          emit: (ctx) => {
+            const child = {
+              type: "section",
+              text: {
+                type: "mrkdwn",
+                text: clampSectionText(body.length > 0 ? body : " ", ctx, "html.details.body")
+              }
+            };
+            const block = {
+              type: "container",
+              title: {
+                type: "plain_text",
+                text: clampContainerTitle(title.length > 0 ? title : "Details", ctx)
+              },
+              child_blocks: [child].slice(0, CONTAINER_CHILDREN_MAX),
+              is_collapsible: true
+            };
+            return [block];
+          }
+        },
+        {
+          budget: { blocks: 1 },
+          emit: (ctx) => {
+            ctx.degradations.add({
+              nodeType: "html.details",
+              from: "container",
+              to: "section",
+              reason: "containerBlock unavailable",
+              path: ctx.path
+            });
+            return [
+              {
+                type: "section",
+                text: {
+                  type: "mrkdwn",
+                  text: clampSectionText(`*${title}*
+${body}`, ctx, "html.details.section")
+                }
+              }
+            ];
+          }
+        }
+      ];
+    }
+    return [
+      {
+        budget: { blocks: 1 },
+        emit: (ctx) => {
+          ctx.degradations.add({
+            nodeType: "html",
+            from: "html",
+            to: "section",
+            reason: "Unsupported block HTML stripped to text",
+            path: ctx.path
+          });
+          const text = stripTags(html.value).trim();
+          if (text.length === 0) {
+            return [];
+          }
+          return [
+            {
+              type: "section",
+              text: { type: "mrkdwn", text: clampSectionText(text, ctx, "html.section") }
+            }
+          ];
+        }
+      }
+    ];
+  }
+};
+function stripTags(html) {
+  return html.replace(/<[^>]{0,200}>/g, "");
+}
+function clampContainerTitle(text, ctx) {
+  if (text.length <= CONTAINER_TITLE_MAX_CHARS) {
+    return text;
+  }
+  ctx.degradations.add({
+    nodeType: "html.details",
+    from: "container.title",
+    to: "truncated",
+    reason: `Container title truncated to ${String(CONTAINER_TITLE_MAX_CHARS)} chars`,
+    path: ctx.path
+  });
+  return text.slice(0, CONTAINER_TITLE_MAX_CHARS);
+}
+
+// src/adapters/list-adapter.ts
+import { toString as toString4 } from "mdast-util-to-string";
+var ListAdapter = class {
+  match(node, _ctx) {
+    if (node.type !== "list") {
+      return false;
+    }
+    return !isTaskList(node);
+  }
+  plan(node, ctx) {
+    const list = node;
+    const hoistCount = countHoistableImagesInList(list, ctx);
+    const candidates = [
+      {
+        budget: { blocks: 1 + hoistCount },
+        emit: (emitCtx) => {
+          return emitListBlocks(list, emitCtx, true);
+        }
+      }
+    ];
+    if (hoistCount > 0) {
+      candidates.push({
+        budget: { blocks: 1 },
+        emit: (emitCtx) => {
+          emitCtx.degradations.add({
+            nodeType: "list",
+            from: "rich_text+images",
+            to: "rich_text",
+            reason: "Budget exhausted for hoisted list images; emitting text only",
+            path: emitCtx.path
+          });
+          return emitListBlocks(list, emitCtx, false);
+        }
+      });
+    }
+    return candidates;
+  }
+};
+function emitListBlocks(list, emitCtx, hoistImages) {
+  const { elements, hoistedImages } = emitListTree(list, 0, emitCtx);
+  const block = { type: "rich_text", elements };
+  const blocks = [block];
+  if (!hoistImages) {
+    return blocks;
+  }
+  for (const h of hoistedImages) {
+    blocks.push(hoistedImageBlock(h, emitCtx));
+  }
+  return blocks;
+}
+function isTaskList(list) {
+  return list.children.some((item) => item.checked === true || item.checked === false);
+}
+function countHoistableImagesInList(list, ctx) {
+  let count = 0;
+  for (const item of list.children) {
+    count += countHoistableImages(collectListItemPhrasing(item), ctx);
+    for (const child of item.children) {
+      if (child.type === "list") {
+        count += countHoistableImagesInList(child, ctx);
+      }
+    }
+  }
+  return count;
+}
+function emitListTree(list, indent, ctx) {
+  let effectiveIndent = indent;
+  if (effectiveIndent > RICH_TEXT_LIST_INDENT_MAX) {
+    ctx.degradations.add({
+      nodeType: "list",
+      from: `indent:${String(effectiveIndent)}`,
+      to: `indent:${String(RICH_TEXT_LIST_INDENT_MAX)}`,
+      reason: "List indent clamped at 6",
+      path: ctx.path
+    });
+    effectiveIndent = RICH_TEXT_LIST_INDENT_MAX;
+  }
+  const sections = [];
+  const nested = [];
+  const hoistedImages = [];
+  for (const item of list.children) {
+    const { section, childLists, hoistedImages: itemImages } = emitListItem(item, ctx);
+    sections.push(section);
+    hoistedImages.push(...itemImages);
+    for (const child of childLists) {
+      const nestedResult = emitListTree(child, effectiveIndent + 1, ctx);
+      nested.push(...nestedResult.elements);
+      hoistedImages.push(...nestedResult.hoistedImages);
+    }
+  }
+  const primary = {
+    type: "rich_text_list",
+    style: list.ordered === true ? "ordered" : "bullet",
+    elements: sections.length > 0 ? sections : [{ type: "rich_text_section", elements: [{ type: "text", text: " " }] }],
+    indent: effectiveIndent,
+    offset: list.ordered === true && list.start !== null && list.start !== void 0 && list.start > 1 ? list.start - 1 : void 0
+  };
+  return { elements: [primary, ...nested], hoistedImages };
+}
+function collectListItemPhrasing(item) {
+  const phrasing = [];
+  let sawBlock = false;
+  for (const child of item.children) {
+    if (child.type === "paragraph") {
+      if (sawBlock) {
+        phrasing.push({ type: "text", value: "\n" });
+      }
+      phrasing.push(...child.children);
+      sawBlock = true;
+    } else if (child.type !== "list") {
+      sawBlock = true;
+    }
+  }
+  return phrasing;
+}
+function emitListItem(item, ctx) {
+  const phrasing = [];
+  const childLists = [];
+  let sawBlock = false;
+  for (const child of item.children) {
+    if (child.type === "paragraph") {
+      if (sawBlock) {
+        phrasing.push({ type: "text", value: "\n" });
+      }
+      phrasing.push(...child.children);
+      sawBlock = true;
+    } else if (child.type === "list") {
+      childLists.push(child);
+    } else {
+      ctx.degradations.add({
+        nodeType: "listItem",
+        from: child.type,
+        to: "text",
+        reason: "Block child of list item flattened into text",
+        path: ctx.path
+      });
+      const text = toString4(child);
+      if (text.length > 0) {
+        phrasing.push({ type: "text", value: text });
+      }
+      sawBlock = true;
+    }
+  }
+  const inline = emitPhrasing(phrasing, ctx);
+  return {
+    section: {
+      type: "rich_text_section",
+      elements: inline.elements.length > 0 ? inline.elements : [{ type: "text", text: " " }]
+    },
+    childLists,
+    hoistedImages: [...inline.hoistedImages]
+  };
+}
+
+// src/adapters/math-block-adapter.ts
+var MathBlockAdapter = class {
+  match(node, _ctx) {
+    return node.type === "math";
+  }
+  plan(node, _ctx) {
+    const value = "value" in node && typeof node.value === "string" ? node.value : "";
+    return [
+      {
+        requires: ["preformattedLanguage"],
+        budget: { blocks: 1 },
+        emit: (ctx) => {
+          return [preformattedMath(value, true, ctx)];
+        }
+      },
+      {
+        budget: { blocks: 1 },
+        emit: (ctx) => {
+          ctx.degradations.add({
+            nodeType: "math",
+            from: "preformatted.language",
+            to: "preformatted",
+            reason: "preformattedLanguage capability unavailable; omitting language",
+            path: ctx.path
+          });
+          return [preformattedMath(value, false, ctx)];
+        }
+      }
+    ];
+  }
+};
+function preformattedMath(value, withLang, ctx) {
+  ctx.degradations.add({
+    nodeType: "math",
+    from: "math",
+    to: "rich_text_preformatted",
+    reason: "No math renderer configured; emitting TeX source",
+    path: ctx.path
+  });
+  return preformattedRichText(value, withLang ? "latex" : void 0);
+}
+
+// src/adapters/mermaid-fence-adapter.ts
+var MermaidFenceAdapter = class {
+  pieParser;
+  xyParser;
+  constructor(deps) {
+    this.pieParser = deps.pieParser;
+    this.xyParser = deps.xyParser;
+  }
+  match(node, _ctx) {
+    return node.type === "code" && (node.lang ?? "").toLowerCase() === "mermaid";
+  }
+  plan(node, ctx) {
+    const code = node;
+    const source = code.value;
+    const kind = detectMermaidKind(source);
+    const candidates = [];
+    const probeCtx = ctx.withDegradations(new RecordingDegradationCollector());
+    if (kind === "pie") {
+      const parsed = this.pieParser.parse(source);
+      if (parsed.ok && parsed.value.kind === "pie") {
+        const probe = tryPieBlock(parsed.value, probeCtx);
+        if (probe !== void 0) {
+          const ast = parsed.value;
+          candidates.push({
+            requires: ["dataVisualization"],
+            budget: { blocks: 1, chart: true },
+            emit: (emitCtx) => {
+              const block = tryPieBlock(ast, emitCtx);
+              return block !== void 0 ? [block] : [];
+            }
+          });
+        }
+      }
+    } else if (kind === "xychart-beta") {
+      const parsed = this.xyParser.parse(source);
+      if (parsed.ok && parsed.value.kind === "xychart-beta") {
+        const probe = tryXyBlock(parsed.value, probeCtx);
+        if (probe !== void 0) {
+          const ast = parsed.value;
+          candidates.push({
+            requires: ["dataVisualization"],
+            budget: { blocks: 1, chart: true },
+            emit: (emitCtx) => {
+              const block = tryXyBlock(ast, emitCtx);
+              return block !== void 0 ? [block] : [];
+            }
+          });
+        }
+      }
+    }
+    candidates.push({
+      budget: { blocks: 1 },
+      emit: async (emitCtx) => {
+        const rendered = await tryRenderers(source, emitCtx);
+        if (rendered !== void 0) {
+          return [rendered];
+        }
+        emitCtx.degradations.add({
+          nodeType: "code.mermaid",
+          from: kind,
+          to: "rich_text_preformatted",
+          reason: "No native chart / renderer image; emitting mermaid source",
+          path: emitCtx.path
+        });
+        return [preformattedMermaid(source, emitCtx)];
+      }
+    });
+    return candidates;
+  }
+};
+function detectMermaidKind(source) {
+  const first = source.split(/\r?\n/).map((l) => l.replace(/%%[^\n]{0,500}/, "").trim()).find((l) => l.length > 0);
+  if (first === void 0) {
+    return "other";
+  }
+  if (/^pie\b/i.test(first)) {
+    return "pie";
+  }
+  if (/^xychart-beta\b/i.test(first)) {
+    return "xychart-beta";
+  }
+  return "other";
+}
+function tryPieBlock(ast, ctx) {
+  if (ast.segments.length > CHART_SEGMENTS_MAX) {
+    ctx.degradations.add({
+      nodeType: "code.mermaid.pie",
+      from: "data_visualization",
+      to: "fallback",
+      reason: `Pie has ${String(ast.segments.length)} segments (max ${String(CHART_SEGMENTS_MAX)})`,
+      path: ctx.path
+    });
+    return void 0;
+  }
+  const segments = ast.segments.map((s) => {
+    const t = truncateLabel(s.label, CHART_LABEL_MAX_CHARS);
+    if (t.truncated) {
+      ctx.degradations.add({
+        nodeType: "code.mermaid.pie",
+        from: s.label,
+        to: t.text,
+        reason: "Pie label truncated to 20 chars",
+        path: ctx.path
+      });
+    }
+    return { label: t.text, value: s.value };
+  });
+  const titleRaw = ast.title ?? (ctx.precedingHeading !== void 0 && ctx.precedingHeading.length > 0 ? ctx.precedingHeading : "Chart");
+  return {
+    type: "data_visualization",
+    title: truncateChartTitle(titleRaw, ctx, "code.mermaid.pie"),
+    chart: { type: "pie", segments }
+  };
+}
+function tryXyBlock(ast, ctx) {
+  const categories = ast.categories.map((c) => {
+    const t = truncateLabel(c, CHART_LABEL_MAX_CHARS);
+    if (t.truncated) {
+      ctx.degradations.add({
+        nodeType: "code.mermaid.xychart",
+        from: c,
+        to: t.text,
+        reason: "Category label truncated to 20 chars",
+        path: ctx.path
+      });
+    }
+    return t.text;
+  });
+  if (categories.length > CHART_POINTS_MAX) {
+    ctx.degradations.add({
+      nodeType: "code.mermaid.xychart",
+      from: "data_visualization",
+      to: "fallback",
+      reason: `xychart has ${String(categories.length)} points (max ${String(CHART_POINTS_MAX)})`,
+      path: ctx.path
+    });
+    return void 0;
+  }
+  let chartType = "bar";
+  let seriesValues = ast.bars;
+  if (ast.bars.length > 0 && ast.lines.length > 0) {
+    ctx.degradations.add({
+      nodeType: "code.mermaid.xychart",
+      from: "mixed bar+line",
+      to: "bar",
+      reason: "Slack charts are single-type; preferring bar",
+      path: ctx.path
+    });
+  } else if (ast.bars.length === 0) {
+    chartType = "line";
+    seriesValues = ast.lines;
+  }
+  if (seriesValues.length === 0 || seriesValues.length > CHART_SERIES_MAX) {
+    ctx.degradations.add({
+      nodeType: "code.mermaid.xychart",
+      from: "data_visualization",
+      to: "fallback",
+      reason: `Invalid series count (${String(seriesValues.length)})`,
+      path: ctx.path
+    });
+    return void 0;
+  }
+  for (const [i, values] of seriesValues.entries()) {
+    if (values.length !== categories.length) {
+      ctx.degradations.add({
+        nodeType: "code.mermaid.xychart",
+        from: `series[${String(i)}].length=${String(values.length)}`,
+        to: `categories.length=${String(categories.length)}`,
+        reason: "xychart series length mismatched categories; padded/truncated by index",
+        path: ctx.path
+      });
+    }
+  }
+  const series = seriesValues.map((values, i) => ({
+    name: truncateLabel(`Series ${String(i + 1)}`, CHART_LABEL_MAX_CHARS).text,
+    data: categories.map((label, idx) => ({
+      label,
+      value: values[idx] ?? 0
+    }))
+  }));
+  const titleRaw = ast.title ?? (ctx.precedingHeading !== void 0 && ctx.precedingHeading.length > 0 ? ctx.precedingHeading : "Chart");
+  return {
+    type: "data_visualization",
+    title: truncateChartTitle(titleRaw, ctx, "code.mermaid.xychart"),
+    chart: {
+      type: chartType,
+      series,
+      axis_config: {
+        categories,
+        x_label: ast.xLabel !== void 0 ? truncateChartTitle(ast.xLabel, ctx, "code.mermaid.xychart") : void 0,
+        y_label: ast.yLabel !== void 0 ? truncateChartTitle(ast.yLabel, ctx, "code.mermaid.xychart") : void 0
+      }
+    }
+  };
+}
+function truncateChartTitle(raw, ctx, nodeType) {
+  const t = truncateLabel(raw, CHART_TITLE_MAX_CHARS);
+  if (t.truncated) {
+    ctx.degradations.add({
+      nodeType,
+      from: raw,
+      to: t.text,
+      reason: `Chart title truncated to ${String(CHART_TITLE_MAX_CHARS)} chars`,
+      path: ctx.path
+    });
+  }
+  return t.text;
+}
+async function tryRenderers(source, ctx) {
+  const req = {
+    lang: "mermaid",
+    source,
+    altText: "mermaid diagram"
+  };
+  for (const renderer of ctx.config.renderers) {
+    if (!renderer.canRender(req)) {
+      continue;
+    }
+    const result = await renderer.render(req);
+    if (result === null) {
+      continue;
+    }
+    if (result.kind === "url") {
+      if (result.imageUrl.length > IMAGE_URL_MAX_CHARS) {
+        ctx.degradations.add({
+          nodeType: "code.mermaid",
+          from: "image.url",
+          to: "skip",
+          reason: "Renderer URL exceeds 3000 chars",
+          path: ctx.path
+        });
+        continue;
+      }
+      return {
+        type: "image",
+        image_url: result.imageUrl,
+        alt_text: clampImageText(result.altText, ctx, "alt_text")
+      };
+    }
+    const uploader = ctx.config.uploader;
+    if (uploader === void 0) {
+      ctx.degradations.add({
+        nodeType: "code.mermaid",
+        from: "image.bytes",
+        to: "skip",
+        reason: "Bytes renderer requires options.uploader",
+        path: ctx.path
+      });
+      continue;
+    }
+    const uploaded = await uploader.upload(result);
+    return {
+      type: "image",
+      alt_text: clampImageText(result.altText, ctx, "alt_text"),
+      slack_file: { id: uploaded.fileId }
+    };
+  }
+  return void 0;
+}
+function preformattedMermaid(source, ctx) {
+  const withLang = ctx.config.capabilities.preformattedLanguage;
+  if (!withLang) {
+    ctx.degradations.add({
+      nodeType: "code.mermaid",
+      from: "preformatted.language",
+      to: "preformatted",
+      reason: "preformattedLanguage capability unavailable; omitting language",
+      path: ctx.path
+    });
+  }
+  return preformattedRichText(source, withLang ? "mermaid" : void 0);
+}
+
+// src/adapters/paragraph-adapter.ts
+var ParagraphAdapter = class {
+  match(node, _ctx) {
+    return node.type === "paragraph";
+  }
+  plan(node, ctx) {
+    const paragraph = node;
+    const loneImage = paragraph.children.length === 1 && paragraph.children[0]?.type === "image" ? paragraph.children[0] : void 0;
+    const hoistCount = loneImage !== void 0 ? 0 : countHoistableImages(paragraph.children, ctx);
+    const candidates = [
+      {
+        budget: { blocks: 1 + hoistCount },
+        emit: (emitCtx) => {
+          return emitParagraph(paragraph, emitCtx, loneImage, true);
+        }
+      }
+    ];
+    if (hoistCount > 0) {
+      candidates.push({
+        budget: { blocks: 1 },
+        emit: (emitCtx) => {
+          emitCtx.degradations.add({
+            nodeType: "paragraph",
+            from: "rich_text+images",
+            to: "rich_text",
+            reason: "Budget exhausted for hoisted paragraph images; emitting text only",
+            path: emitCtx.path
+          });
+          return emitParagraph(paragraph, emitCtx, loneImage, false);
+        }
+      });
+    }
+    return candidates;
+  }
+};
+function emitParagraph(paragraph, emitCtx, loneImage, hoistImages) {
+  if (loneImage !== void 0 && loneImage.type === "image") {
+    const img = loneImage;
+    if (isPublicImageUrl(img.url)) {
+      const altRaw = img.alt ?? "image";
+      const alt = clampImageText(altRaw.length > 0 ? altRaw : "image", emitCtx, "alt_text");
+      const block = {
+        type: "image",
+        image_url: img.url,
+        alt_text: alt,
+        title: img.title !== null && img.title !== void 0 && img.title.length > 0 ? {
+          type: "plain_text",
+          text: clampImageText(img.title, emitCtx, "title")
+        } : void 0
+      };
+      return [block];
+    }
+    emitCtx.degradations.add({
+      nodeType: "image",
+      from: "image",
+      to: "section.link",
+      reason: "Non-public or invalid image URL",
+      path: emitCtx.path
+    });
+    const linkText = `<${img.url}|${img.alt ?? img.url}>`;
+    return [
+      {
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: clampSectionText(linkText, emitCtx, "section")
+        }
+      }
+    ];
+  }
+  const inline = emitPhrasing(paragraph.children, emitCtx);
+  const blocks = [];
+  const rich = {
+    type: "rich_text",
+    elements: [
+      {
+        type: "rich_text_section",
+        elements: inline.elements.length > 0 ? inline.elements : [{ type: "text", text: " " }]
+      }
+    ]
+  };
+  blocks.push(rich);
+  if (!hoistImages) {
+    return blocks;
+  }
+  for (const h of inline.hoistedImages) {
+    blocks.push(hoistedImageBlock(h, emitCtx));
+  }
+  return blocks;
+}
+
+// src/adapters/skip-adapter.ts
+var SkipAdapter = class {
+  match(node, _ctx) {
+    const t = node.type;
+    return t === "definition" || t === "yaml" || t === "toml" || t === "footnoteDefinition";
+  }
+  plan(node, _ctx) {
+    return [
+      {
+        emit: (ctx) => {
+          const t = node.type;
+          if (t === "yaml" || t === "toml") {
+            ctx.degradations.add({
+              nodeType: t,
+              from: "frontmatter",
+              to: "skip",
+              reason: "Frontmatter skipped by default",
+              path: ctx.path
+            });
+          }
+          return [];
+        }
+      }
+    ];
+  }
+};
+
+// src/adapters/table-adapter.ts
+import { toString as toString5 } from "mdast-util-to-string";
+var TableAdapter = class {
+  match(node, _ctx) {
+    return node.type === "table";
+  }
+  plan(node, ctx) {
+    const table = node;
+    const rowCount = table.children.length;
+    const colCount = table.children[0]?.children.length ?? 0;
+    const cellChars = countEmittedCellChars(table, ctx);
+    if (colCount > TABLE_MAX_COLS) {
+      return markdownThenAscii(table, cellChars, "Table exceeds 20 columns");
+    }
+    if (rowCount <= TABLE_PREFERRED_MAX_ROWS) {
+      return [
+        {
+          requires: ["tableBlock"],
+          budget: { blocks: 1, tableChars: cellChars },
+          emit: (ctx2) => {
+            return [buildTableBlock(table, ctx2)];
+          }
+        },
+        ...markdownThenAscii(table, cellChars, "tableBlock unavailable or char budget")
+      ];
+    }
+    const dataRows = Math.max(0, rowCount - 1);
+    if (dataRows <= DATA_TABLE_MAX_DATA_ROWS) {
+      const preferredTable = truncateRows(table, TABLE_PREFERRED_MAX_ROWS);
+      const preferredChars = countEmittedCellChars(preferredTable, ctx);
+      return [
+        {
+          requires: ["dataTable"],
+          budget: { blocks: 1, dataTableChars: cellChars },
+          emit: (emitCtx) => {
+            emitCtx.degradations.add({
+              nodeType: "table",
+              from: "table",
+              to: "data_table",
+              reason: `Table has ${String(rowCount)} rows (>${String(TABLE_PREFERRED_MAX_ROWS)}); using data_table`,
+              path: emitCtx.path
+            });
+            return [buildDataTable(table, emitCtx)];
+          }
+        },
+        {
+          requires: ["tableBlock"],
+          budget: { blocks: 1, tableChars: preferredChars },
+          emit: (emitCtx) => {
+            emitCtx.degradations.add({
+              nodeType: "table",
+              from: "data_table",
+              to: "table",
+              reason: "dataTable unavailable; truncating to table block capacity",
+              path: emitCtx.path
+            });
+            return [buildTableBlock(preferredTable, emitCtx)];
+          }
+        },
+        ...markdownThenAscii(table, cellChars, "native table unavailable")
+      ];
+    }
+    const dataChunk = truncateRows(table, DATA_TABLE_MAX_DATA_ROWS + 1);
+    const dataChunkChars = countEmittedCellChars(dataChunk, ctx);
+    return [
+      {
+        requires: ["dataTable"],
+        budget: { blocks: 1, dataTableChars: dataChunkChars },
+        emit: (emitCtx) => {
+          emitCtx.degradations.add({
+            nodeType: "table",
+            from: "table",
+            to: "data_table.split",
+            reason: `Table has ${String(dataRows)} data rows; emitting first ${String(DATA_TABLE_MAX_DATA_ROWS)}`,
+            path: emitCtx.path
+          });
+          return [buildDataTable(dataChunk, emitCtx)];
+        }
+      },
+      ...markdownThenAscii(table, cellChars, "oversized table")
+    ];
+  }
+};
+function markdownThenAscii(table, cellChars, reason) {
+  const md = toPipeMarkdown(table);
+  return [
+    {
+      requires: ["markdownBlock"],
+      budget: { blocks: 1, markdownChars: md.length },
+      emit: (ctx) => {
+        ctx.degradations.add({
+          nodeType: "table",
+          from: "native_table",
+          to: "markdown",
+          reason,
+          path: ctx.path
+        });
+        const block = { type: "markdown", text: md };
+        return [block];
+      }
+    },
+    {
+      budget: { blocks: 1 },
+      emit: (ctx) => {
+        ctx.degradations.add({
+          nodeType: "table",
+          from: "markdown",
+          to: "ascii_preformatted",
+          reason: `${reason}; markdown unavailable (chars\u2248${String(cellChars)})`,
+          path: ctx.path
+        });
+        return [asciiTableBlock(table)];
+      }
+    }
+  ];
+}
+function buildTableBlock(table, ctx) {
+  const rows = table.children.map(
+    (row, rowIndex) => row.children.map((cell) => cellToSlack(cell, ctx, rowIndex === 0))
+  );
+  return {
+    type: "table",
+    rows,
+    column_settings: columnSettings(table)
+  };
+}
+function buildDataTable(table, ctx) {
+  const captionRaw = ctx.precedingHeading !== void 0 && ctx.precedingHeading.length > 0 ? ctx.precedingHeading : "Table";
+  const caption = captionRaw.slice(0, 150);
+  if (captionRaw.length > 150) {
+    ctx.degradations.add({
+      nodeType: "table",
+      from: "data_table.caption",
+      to: "truncated",
+      reason: "data_table caption truncated to 150 chars",
+      path: ctx.path
+    });
+  }
+  const rows = table.children.map(
+    (row, rowIndex) => row.children.map((cell) => {
+      if (rowIndex === 0) {
+        return { type: "raw_text", text: toString5(cell) };
+      }
+      return cellToSlack(cell, ctx, false);
+    })
+  );
+  return {
+    type: "data_table",
+    caption,
+    rows,
+    page_size: 5,
+    row_header_column_index: 0
+  };
+}
+function cellToSlack(cell, ctx, header) {
+  const plain = toString5(cell);
+  const styled = cell.children.some(
+    (c) => c.type === "strong" || c.type === "emphasis" || c.type === "delete" || c.type === "link" || c.type === "inlineCode"
+  );
+  if (!styled) {
+    if (!header && /^-?\d+(\.\d+)?$/.test(plain.trim())) {
+      const value = Number(plain.trim());
+      return { type: "raw_number", value, text: plain.trim() };
+    }
+    return { type: "raw_text", text: plain };
+  }
+  const inline = emitPhrasing(cell.children, ctx);
+  const rich = {
+    type: "rich_text",
+    elements: [
+      {
+        type: "rich_text_section",
+        elements: inline.elements.length > 0 ? inline.elements : [{ type: "text", text: plain }]
+      }
+    ]
+  };
+  return rich;
+}
+function columnSettings(table) {
+  const align = table.align ?? [];
+  const colCount = table.children[0]?.children.length ?? 0;
+  const settings = [];
+  for (let i = 0; i < colCount; i += 1) {
+    const a = align[i];
+    const long = table.children.some(
+      (row) => toString5(row.children[i] ?? { type: "text", value: "" }).length > TABLE_CELL_WRAP_THRESHOLD
+    );
+    const alignVal = a === "left" || a === "center" || a === "right" ? a : void 0;
+    if (alignVal === void 0 && !long) {
+      settings.push(null);
+    } else {
+      settings.push({
+        align: alignVal,
+        is_wrapped: long ? true : void 0
+      });
+    }
+  }
+  return settings;
+}
+function countEmittedCellChars(table, ctx) {
+  const probe = ctx.withDegradations(new RecordingDegradationCollector());
+  let n = 0;
+  for (const [rowIndex, row] of table.children.entries()) {
+    for (const cell of row.children) {
+      n += slackCellCharCount(cellToSlack(cell, probe, rowIndex === 0));
+    }
+  }
+  return n;
+}
+function slackCellCharCount(cell) {
+  if (cell.type === "raw_text" || cell.type === "raw_number") {
+    return cell.text.length;
+  }
+  return JSON.stringify(cell).length;
+}
+function truncateRows(table, maxRows) {
+  return {
+    ...table,
+    children: table.children.slice(0, maxRows)
+  };
+}
+function toPipeMarkdown(table) {
+  const rows = table.children.map(
+    (row) => row.children.map((c) => toString5(c).replace(/\|/g, "\\|"))
+  );
+  if (rows.length === 0) {
+    return "";
+  }
+  const header = rows[0] ?? [];
+  const align = table.align ?? [];
+  const sep = header.map((_, i) => {
+    const a = align[i];
+    if (a === "center") return ":---:";
+    if (a === "right") return "---:";
+    if (a === "left") return ":---";
+    return "---";
+  });
+  const lines = [
+    `| ${header.join(" | ")} |`,
+    `| ${sep.join(" | ")} |`,
+    ...rows.slice(1).map((r) => `| ${r.join(" | ")} |`)
+  ];
+  return lines.join("\n");
+}
+function asciiTableBlock(table) {
+  return preformattedRichText(toPipeMarkdown(table), void 0);
+}
+
+// src/adapters/task-list-adapter.ts
+import { toString as toString6 } from "mdast-util-to-string";
+var TaskListAdapter = class {
+  match(node, _ctx) {
+    return node.type === "list" && isTaskList(node);
+  }
+  plan(node, _ctx) {
+    const list = node;
+    const md = serializeTaskList(list);
+    return [
+      {
+        requires: ["markdownBlock"],
+        budget: { blocks: 1, markdownChars: md.length },
+        emit: () => {
+          const block = { type: "markdown", text: md };
+          return [block];
+        }
+      },
+      {
+        budget: { blocks: 1 },
+        emit: (ctx) => {
+          ctx.degradations.add({
+            nodeType: "list",
+            from: "markdown.task_list",
+            to: "rich_text_list.unicode_checkbox",
+            reason: "markdownBlock unavailable or budget exhausted",
+            path: ctx.path
+          });
+          return [unicodeTaskList(list, ctx)];
+        }
+      }
+    ];
+  }
+};
+function serializeTaskList(list, indent = 0) {
+  const pad = "  ".repeat(indent);
+  const lines = [];
+  for (const item of list.children) {
+    const checked = item.checked === true;
+    const box = checked ? "[x]" : "[ ]";
+    const text = itemText(item);
+    lines.push(`${pad}- ${box} ${text}`);
+    for (const child of item.children) {
+      if (child.type === "list") {
+        lines.push(serializeTaskList(child, indent + 1));
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function itemText(item) {
+  const parts = [];
+  for (const child of item.children) {
+    if (child.type === "paragraph") {
+      parts.push(toString6(child));
+    } else if (child.type !== "list") {
+      parts.push(toString6(child));
+    }
+  }
+  return parts.join(" ").trim();
+}
+function unicodeTaskList(list, ctx) {
+  return {
+    type: "rich_text",
+    elements: emitUnicodeTaskTree(list, 0, ctx)
+  };
+}
+function emitUnicodeTaskTree(list, indent, ctx) {
+  let effectiveIndent = indent;
+  if (effectiveIndent > RICH_TEXT_LIST_INDENT_MAX) {
+    ctx.degradations.add({
+      nodeType: "list",
+      from: `indent:${String(effectiveIndent)}`,
+      to: `indent:${String(RICH_TEXT_LIST_INDENT_MAX)}`,
+      reason: "Task list indent clamped at 6",
+      path: ctx.path
+    });
+    effectiveIndent = RICH_TEXT_LIST_INDENT_MAX;
+  }
+  const sections = [];
+  const nested = [];
+  for (const item of list.children) {
+    const prefix = item.checked === true ? "\u2611 " : item.checked === false ? "\u2610 " : "";
+    sections.push({
+      type: "rich_text_section",
+      elements: [{ type: "text", text: `${prefix}${itemText(item)}` }]
+    });
+    for (const child of item.children) {
+      if (child.type === "list") {
+        nested.push(...emitUnicodeTaskTree(child, effectiveIndent + 1, ctx));
+      }
+    }
+  }
+  const primary = {
+    type: "rich_text_list",
+    style: "bullet",
+    elements: sections.length > 0 ? sections : [{ type: "rich_text_section", elements: [{ type: "text", text: " " }] }],
+    indent: effectiveIndent
+  };
+  return [primary, ...nested];
+}
+
+// src/adapters/thematic-break-adapter.ts
+var ThematicBreakAdapter = class {
+  match(node, _ctx) {
+    return node.type === "thematicBreak";
+  }
+  plan(_node, _ctx) {
+    return [
+      {
+        budget: { blocks: 1 },
+        emit: (_ctx2) => [{ type: "divider" }]
+      }
+    ];
+  }
+};
+
+// src/converter/create-converter.ts
+function createConverter(options = {}) {
+  const parser = options.parser ?? new RemarkMarkdownParser();
+  const plainText = options.plainText ?? new DeterministicPlainTextRenderer();
+  const pieParser = new MermaidPieParser();
+  const xyParser = new MermaidXyChartParser();
+  const builtIns = [
+    new MermaidFenceAdapter({ pieParser, xyParser }),
+    new MathBlockAdapter(),
+    new TaskListAdapter(),
+    new ListAdapter(),
+    new TableAdapter(),
+    new HeadingAdapter(),
+    new ParagraphAdapter(),
+    new BlockquoteAdapter(),
+    new CodeFenceAdapter(),
+    new ThematicBreakAdapter(),
+    new HtmlBlockAdapter(),
+    new SkipAdapter()
+  ];
+  const registry = new AdapterRegistry([...options.adapters ?? [], ...builtIns]);
+  const assembler = new MessageAssembler({ plainText });
+  const defaultOptions = {
+    capabilities: options.capabilities,
+    capabilityOverrides: options.capabilityOverrides,
+    overflow: options.overflow ?? OverflowMode.Degrade,
+    strategy: options.strategy,
+    renderers: options.renderers ?? [],
+    uploader: options.uploader,
+    enableMath: options.enableMath,
+    enableFrontmatter: options.enableFrontmatter,
+    mentionResolvers: options.mentionResolvers
+  };
+  return new SlackMarkConverter({
+    parser,
+    registry,
+    assembler,
+    plainText,
+    defaultOptions
+  });
+}
+function convert(markdown, options) {
+  return createConverter(options).convert(markdown, options);
+}
+function convertToMessages(markdown, options) {
+  return createConverter(options).convertToMessages(markdown, options);
+}
+
+// src/validate/validate-blocks.ts
+function validateBlocks(blocks) {
+  const issues = [];
+  if (blocks.length > MAX_BLOCKS_PER_MESSAGE) {
+    issues.push({
+      path: "$",
+      message: `Too many blocks: ${String(blocks.length)} > ${String(MAX_BLOCKS_PER_MESSAGE)}`
+    });
+  }
+  let markdownChars = 0;
+  let tableChars = 0;
+  let dataTableChars = 0;
+  let charts = 0;
+  blocks.forEach((block, i) => {
+    const path = `blocks[${String(i)}]`;
+    switch (block.type) {
+      case "header":
+        if (block.text.text.length > HEADER_TEXT_MAX_CHARS) {
+          issues.push({ path, message: "header text > 150" });
+        }
+        if (block.level !== void 0 && (block.level < 1 || block.level > 4)) {
+          issues.push({ path, message: "header level out of 1\u20134" });
+        }
+        break;
+      case "section":
+        if (block.text !== void 0 && block.text.text.length > SECTION_TEXT_MAX_CHARS) {
+          issues.push({ path, message: "section text > 3000" });
+        }
+        break;
+      case "image":
+        if (block.alt_text.length > IMAGE_ALT_MAX_CHARS) {
+          issues.push({ path, message: "image alt > 2000" });
+        }
+        if (block.image_url !== void 0 && block.image_url.length > IMAGE_URL_MAX_CHARS) {
+          issues.push({ path, message: "image_url > 3000" });
+        }
+        break;
+      case "context":
+        if (block.elements.length > CONTEXT_ELEMENTS_MAX) {
+          issues.push({ path, message: "context elements > 10" });
+        }
+        break;
+      case "markdown":
+        markdownChars += block.text.length;
+        break;
+      case "table": {
+        if (block.rows.length > TABLE_MAX_ROWS) {
+          issues.push({ path, message: "table rows > 100" });
+        }
+        for (const row of block.rows) {
+          if (row.length > TABLE_MAX_COLS) {
+            issues.push({ path, message: "table cols > 20" });
+          }
+          for (const cell of row) {
+            tableChars += cellCharCount(cell);
+          }
+        }
+        break;
+      }
+      case "data_table": {
+        if (block.rows.length > DATA_TABLE_MAX_DATA_ROWS + 1) {
+          issues.push({ path, message: "data_table rows > 201" });
+        }
+        for (const row of block.rows) {
+          if (row.length > TABLE_MAX_COLS) {
+            issues.push({ path, message: "data_table cols > 20" });
+          }
+          for (const cell of row) {
+            dataTableChars += cellCharCount(cell);
+          }
+        }
+        break;
+      }
+      case "data_visualization":
+        charts += 1;
+        if (block.title.length > CHART_TITLE_MAX_CHARS) {
+          issues.push({ path, message: "chart title > 50" });
+        }
+        validateChart(block, path, issues);
+        break;
+      case "container":
+        if (block.child_blocks.length > CONTAINER_CHILDREN_MAX) {
+          issues.push({ path, message: "container children > 10" });
+        }
+        if (block.title !== void 0 && block.title.text.length > CONTAINER_TITLE_MAX_CHARS) {
+          issues.push({ path, message: "container title > 150" });
+        }
+        break;
+      case "divider":
+      case "rich_text":
+        break;
+      default: {
+        const exhaustive = block;
+        void exhaustive;
+        break;
+      }
+    }
+  });
+  if (markdownChars > MARKDOWN_CUMULATIVE_MAX_CHARS) {
+    issues.push({
+      path: "$",
+      message: `markdown cumulative ${String(markdownChars)} > 12000`
+    });
+  }
+  if (tableChars > TABLE_CELL_CHARS_MAX) {
+    issues.push({
+      path: "$",
+      message: `table chars ${String(tableChars)} > 10000`
+    });
+  }
+  if (dataTableChars > DATA_TABLE_CELL_CHARS_MAX) {
+    issues.push({
+      path: "$",
+      message: `data_table chars ${String(dataTableChars)} > 20000`
+    });
+  }
+  if (charts > DATA_VISUALIZATION_MAX_PER_MESSAGE) {
+    issues.push({
+      path: "$",
+      message: `charts ${String(charts)} > ${String(DATA_VISUALIZATION_MAX_PER_MESSAGE)}`
+    });
+  }
+  if (issues.length > 0) {
+    const detail = issues.map((x) => `${x.path}: ${x.message}`).join("; ");
+    throw new Error(`validateBlocks failed: ${detail}`);
+  }
+  return blocks;
+}
+function cellCharCount(cell) {
+  if (cell.type === "raw_text") {
+    return cell.text.length;
+  }
+  if (cell.type === "raw_number") {
+    return cell.text.length;
+  }
+  return JSON.stringify(cell).length;
+}
+function validateChart(block, path, issues) {
+  const chart = block.chart;
+  if (chart.type === "pie") {
+    if (chart.segments.length < 1 || chart.segments.length > CHART_SEGMENTS_MAX) {
+      issues.push({ path, message: "pie segments out of 1\u201312" });
+    }
+    for (const s of chart.segments) {
+      if (s.label.length > CHART_LABEL_MAX_CHARS) {
+        issues.push({ path, message: "pie label > 20" });
+      }
+      if (!(s.value > 0)) {
+        issues.push({ path, message: "pie value must be > 0" });
+      }
+    }
+    return;
+  }
+  if (chart.series.length < 1 || chart.series.length > CHART_SERIES_MAX) {
+    issues.push({ path, message: "series out of 1\u201312" });
+  }
+  if (chart.axis_config.categories.length > CHART_POINTS_MAX) {
+    issues.push({ path, message: "categories > 20" });
+  }
+  for (const s of chart.series) {
+    if (s.name.length > CHART_LABEL_MAX_CHARS) {
+      issues.push({ path, message: "series name > 20" });
+    }
+    if (s.data.length < 1 || s.data.length > CHART_POINTS_MAX) {
+      issues.push({ path, message: "points out of 1\u201320" });
+    }
+    for (const p of s.data) {
+      if (p.label.length > CHART_LABEL_MAX_CHARS) {
+        issues.push({ path, message: "point label > 20" });
+      }
+      if (!chart.axis_config.categories.includes(p.label)) {
+        issues.push({ path, message: `point label ${p.label} missing from categories` });
+      }
+    }
+  }
+}
+export {
+  AdapterRegistry,
+  CAPABILITY_PRESETS,
+  CapabilityPresetName,
+  ConfigurationError,
+  ConversionContext,
+  ConversionStrategy as ConversionStrategies,
+  DeterministicPlainTextRenderer,
+  MermaidPieParser,
+  MermaidXyChartParser,
+  MessageAssembler,
+  OverflowMode as OverflowModes,
+  RecordingDegradationCollector,
+  RemarkMarkdownParser,
+  SlackMarkConverter,
+  StandardBudgetLedger,
+  convert,
+  convertToMessages,
+  createConverter,
+  resolveCapabilities,
+  validateBlocks
+};
+//# sourceMappingURL=index.js.map