poe-code 3.0.144 → 3.0.146

package/dist/index.js

@@ -3337,9 +3337,16 @@ var init_colors = __esm({
 });
 
 // packages/design-system/src/tokens/spacing.ts
+var spacing;
 var init_spacing = __esm({
   "packages/design-system/src/tokens/spacing.ts"() {
     "use strict";
+    spacing = {
+      sm: 1,
+      md: 2,
+      lg: 4,
+      xl: 8
+    };
   }
 });
 
@@ -3436,7 +3443,7 @@ function detectThemeFromEnv(env) {
   return void 0;
 }
 function resolveThemeName(env = process.env) {
-  const raw = env.POE_CODE_THEME?.toLowerCase();
+  const raw = (env.POE_CODE_THEME ?? env.POE_THEME)?.toLowerCase();
   if (raw === "light" || raw === "dark") {
     return raw;
   }
@@ -3838,127 +3845,3424 @@ function formatOption(flags, description) {
   const paddedFlags = flags.padEnd(widths.helpColumn);
   return `  ${text.option(paddedFlags)}  ${description}`;
 }
-function formatCommandList(commands) {
-  return commands.map((cmd) => formatCommand(cmd.name, cmd.description)).join("\n");
+function formatCommandList(commands) {
+  return commands.map((cmd) => formatCommand(cmd.name, cmd.description)).join("\n");
+}
+function formatOptionList(options) {
+  return options.map((opt) => formatOption(opt.flags, opt.description)).join("\n");
+}
+var init_help_formatter = __esm({
+  "packages/design-system/src/components/help-formatter.ts"() {
+    "use strict";
+    init_text();
+    init_widths();
+  }
+});
+
+// packages/design-system/src/components/command-errors.ts
+function formatCommandNotFound(input) {
+  const unknown = input.unknownCommand.length > 0 ? input.unknownCommand : "<command>";
+  return {
+    label: `${typography.bold("Unknown command:")} ${text.command(unknown)}`,
+    hint: `${text.muted("Run")} ${text.usageCommand(input.helpCommand)} ${text.muted("for available commands.")}`
+  };
+}
+function formatCommandNotFoundPanel(input) {
+  const message2 = formatCommandNotFound({
+    unknownCommand: input.unknownCommand,
+    helpCommand: input.helpCommand
+  });
+  return {
+    title: input.title ?? "command not found",
+    label: message2.label,
+    footer: message2.hint
+  };
+}
+var init_command_errors = __esm({
+  "packages/design-system/src/components/command-errors.ts"() {
+    "use strict";
+    init_typography();
+    init_text();
+  }
+});
+
+// packages/design-system/src/components/table.ts
+import { Table } from "console-table-printer";
+function renderTableTerminal(options) {
+  const { theme, columns, rows } = options;
+  const table = new Table({
+    style: {
+      headerTop: {
+        left: theme.muted("\u250C"),
+        mid: theme.muted("\u252C"),
+        right: theme.muted("\u2510"),
+        other: theme.muted("\u2500")
+      },
+      headerBottom: {
+        left: theme.muted("\u251C"),
+        mid: theme.muted("\u253C"),
+        right: theme.muted("\u2524"),
+        other: theme.muted("\u2500")
+      },
+      tableBottom: {
+        left: theme.muted("\u2514"),
+        mid: theme.muted("\u2534"),
+        right: theme.muted("\u2518"),
+        other: theme.muted("\u2500")
+      },
+      vertical: theme.muted("\u2502"),
+      rowSeparator: {
+        left: theme.muted("\u251C"),
+        mid: theme.muted("\u253C"),
+        right: theme.muted("\u2524"),
+        other: theme.muted("\u2500")
+      }
+    },
+    columns: columns.map((col) => ({
+      name: col.name,
+      title: theme.header(col.title),
+      alignment: col.alignment,
+      maxLen: col.maxLen
+    }))
+  });
+  for (const row of rows) {
+    table.addRow(row);
+  }
+  return table.render();
+}
+function renderTableMarkdown(options) {
+  const { columns, rows } = options;
+  const header = `| ${columns.map((c) => c.title).join(" | ")} |`;
+  const separator = `| ${columns.map((c) => c.alignment === "right" ? "---:" : ":---").join(" | ")} |`;
+  const dataRows = rows.map(
+    (row) => `| ${columns.map((c) => stripAnsi2(row[c.name] ?? "").replace(/\|/g, "\\|")).join(" | ")} |`
+  );
+  return [header, separator, ...dataRows].join("\n");
+}
+function renderTableJson(options) {
+  const { columns, rows } = options;
+  const cleaned = rows.map((row) => {
+    const obj = {};
+    for (const col of columns) {
+      obj[col.name] = stripAnsi2(row[col.name] ?? "");
+    }
+    return obj;
+  });
+  return JSON.stringify(cleaned, null, 2);
+}
+function renderTable(options) {
+  const format = resolveOutputFormat();
+  switch (format) {
+    case "markdown":
+      return renderTableMarkdown(options);
+    case "json":
+      return renderTableJson(options);
+    default:
+      return renderTableTerminal(options);
+  }
+}
+var init_table = __esm({
+  "packages/design-system/src/components/table.ts"() {
+    "use strict";
+    init_output_format();
+    init_strip_ansi();
+  }
+});
+
+// packages/design-system/src/terminal-markdown/parser/frontmatter.ts
+function extractFrontmatter(markdown) {
+  const content = stripBom(markdown);
+  if (!startsWithFrontmatterFence(content)) {
+    return { body: markdown };
+  }
+  const openingLine = readLine(content, 0);
+  let position = openingLine.nextPosition;
+  let closingFenceStart;
+  let closingFenceNextPosition;
+  while (position <= content.length) {
+    const line = readLine(content, position);
+    if (line.text === "---") {
+      closingFenceStart = line.start;
+      closingFenceNextPosition = line.nextPosition;
+      break;
+    }
+    if (line.nextPosition >= content.length) {
+      break;
+    }
+    position = line.nextPosition;
+  }
+  if (closingFenceStart === void 0 || closingFenceNextPosition === void 0) {
+    return { body: markdown };
+  }
+  const rawFrontmatter = sliceFrontmatterBlock(
+    content,
+    openingLine.nextPosition,
+    closingFenceStart
+  );
+  const frontmatter = parseFrontmatterBlock(rawFrontmatter);
+  return {
+    frontmatter,
+    body: content.slice(closingFenceNextPosition)
+  };
+}
+function parseFrontmatterBlock(yamlBlock) {
+  if (yamlBlock.length === 0) {
+    return {};
+  }
+  try {
+    return new YamlSubsetParser(yamlBlock).parse();
+  } catch (error2) {
+    if (error2 instanceof FrontmatterParseError) {
+      return { raw: yamlBlock };
+    }
+    throw error2;
+  }
+}
+function tokenizeYamlBlock(yamlBlock) {
+  const lines = yamlBlock.replaceAll("\r\n", "\n").replaceAll("\r", "\n").split("\n");
+  return lines.map((line) => {
+    let indent = 0;
+    while (indent < line.length && line[indent] === " ") {
+      indent += 1;
+    }
+    for (let index = 0; index < indent; index += 1) {
+      if (line[index] === "	") {
+        throw new FrontmatterParseError("Tabs are not supported in frontmatter indentation.");
+      }
+    }
+    if (indent < line.length && line[indent] === "	") {
+      throw new FrontmatterParseError("Tabs are not supported in frontmatter indentation.");
+    }
+    return {
+      indent,
+      content: line.slice(indent)
+    };
+  });
+}
+function parseKeyValue(content) {
+  const separator = findUnquotedMappingSeparator(content);
+  if (separator === -1) {
+    return null;
+  }
+  const key = trimAsciiWhitespace(content.slice(0, separator));
+  if (key.length === 0) {
+    return null;
+  }
+  const rawValue = trimAsciiWhitespaceStart(content.slice(separator + 1));
+  return rawValue.length === 0 ? { key } : { key, value: rawValue };
+}
+function parseArrayItem(content) {
+  if (!isArrayItem(content)) {
+    return null;
+  }
+  return trimAsciiWhitespaceStart(content.slice(1));
+}
+function isArrayItem(content) {
+  if (!content.startsWith("-")) {
+    return false;
+  }
+  if (content.length === 1) {
+    return true;
+  }
+  const nextCharacter = content[1];
+  return nextCharacter === " " || nextCharacter === "	";
+}
+function parseScalar(value) {
+  if (value.length === 0) {
+    return "";
+  }
+  if (isQuoted(value, "'")) {
+    return value.slice(1, -1).replaceAll("''", "'");
+  }
+  if (isQuoted(value, '"')) {
+    return parseDoubleQuotedString(value.slice(1, -1));
+  }
+  if (value === "true") {
+    return true;
+  }
+  if (value === "false") {
+    return false;
+  }
+  if (value === "null") {
+    return null;
+  }
+  if (isNumberLiteral(value)) {
+    return Number(value);
+  }
+  if (hasUnquotedMappingSeparator(value)) {
+    throw new FrontmatterParseError(
+      "Unquoted mapping separators are not supported in scalar values."
+    );
+  }
+  return value;
+}
+function parseDoubleQuotedString(value) {
+  let result = "";
+  for (let index = 0; index < value.length; index += 1) {
+    const character = value[index];
+    if (character !== "\\") {
+      result += character;
+      continue;
+    }
+    index += 1;
+    if (index >= value.length) {
+      result += "\\";
+      break;
+    }
+    const escaped = value[index];
+    if (escaped === "n") {
+      result += "\n";
+      continue;
+    }
+    if (escaped === "r") {
+      result += "\r";
+      continue;
+    }
+    if (escaped === "t") {
+      result += "	";
+      continue;
+    }
+    if (escaped === "b") {
+      result += "\b";
+      continue;
+    }
+    if (escaped === "f") {
+      result += "\f";
+      continue;
+    }
+    if (escaped === '"' || escaped === "\\" || escaped === "/") {
+      result += escaped;
+      continue;
+    }
+    if (escaped === "u") {
+      const codePoint = value.slice(index + 1, index + 5);
+      if (codePoint.length === 4 && isHexadecimal(codePoint)) {
+        result += String.fromCodePoint(Number.parseInt(codePoint, 16));
+        index += 4;
+        continue;
+      }
+    }
+    result += `\\${escaped}`;
+  }
+  return result;
+}
+function isQuoted(value, quote) {
+  return value.length >= 2 && value[0] === quote && value[value.length - 1] === quote;
+}
+function isNumberLiteral(value) {
+  let index = 0;
+  let hasDigits = false;
+  let hasDecimal = false;
+  if (value[index] === "-" || value[index] === "+") {
+    index += 1;
+  }
+  while (index < value.length) {
+    const character = value[index];
+    if (character >= "0" && character <= "9") {
+      hasDigits = true;
+      index += 1;
+      continue;
+    }
+    if (character === "." && !hasDecimal) {
+      hasDecimal = true;
+      index += 1;
+      continue;
+    }
+    return false;
+  }
+  return hasDigits;
+}
+function hasUnquotedMappingSeparator(value) {
+  return findUnquotedMappingSeparator(value) !== -1;
+}
+function findUnquotedMappingSeparator(value) {
+  let quote = null;
+  for (let index = 0; index < value.length; index += 1) {
+    const character = value[index];
+    if (quote !== null) {
+      if (character === "\\" && quote === '"') {
+        index += 1;
+        continue;
+      }
+      if (character === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (character === "'" || character === '"') {
+      quote = character;
+      continue;
+    }
+    if (character !== ":") {
+      continue;
+    }
+    const nextCharacter = value[index + 1];
+    if (nextCharacter === void 0 || nextCharacter === " " || nextCharacter === "	") {
+      return index;
+    }
+  }
+  return -1;
+}
+function sliceFrontmatterBlock(content, start, end) {
+  let sliceEnd = end;
+  if (sliceEnd > start && content[sliceEnd - 1] === "\n") {
+    sliceEnd -= 1;
+    if (sliceEnd > start && content[sliceEnd - 1] === "\r") {
+      sliceEnd -= 1;
+    }
+  }
+  return content.slice(start, sliceEnd);
+}
+function startsWithFrontmatterFence(value) {
+  return value.startsWith("---\n") || value.startsWith("---\r\n");
+}
+function stripBom(value) {
+  return value.startsWith("\uFEFF") ? value.slice(1) : value;
+}
+function readLine(input, position) {
+  let end = position;
+  while (end < input.length && input[end] !== "\n" && input[end] !== "\r") {
+    end += 1;
+  }
+  let nextPosition = end;
+  if (input[nextPosition] === "\r" && input[nextPosition + 1] === "\n") {
+    nextPosition += 2;
+  } else if (input[nextPosition] === "\n" || input[nextPosition] === "\r") {
+    nextPosition += 1;
+  }
+  return {
+    text: input.slice(position, end),
+    start: position,
+    nextPosition
+  };
+}
+function trimAsciiWhitespace(value) {
+  return trimAsciiWhitespaceEnd(trimAsciiWhitespaceStart(value));
+}
+function trimAsciiWhitespaceStart(value) {
+  let start = 0;
+  while (start < value.length && (value[start] === " " || value[start] === "	")) {
+    start += 1;
+  }
+  return value.slice(start);
+}
+function trimAsciiWhitespaceEnd(value) {
+  let end = value.length;
+  while (end > 0 && (value[end - 1] === " " || value[end - 1] === "	")) {
+    end -= 1;
+  }
+  return value.slice(0, end);
+}
+function hasOwn(record, key) {
+  return Object.prototype.hasOwnProperty.call(record, key);
+}
+function isHexadecimal(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const character = value[index];
+    if (character >= "0" && character <= "9" || character >= "a" && character <= "f" || character >= "A" && character <= "F") {
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+var FrontmatterParseError, YamlSubsetParser;
+var init_frontmatter = __esm({
+  "packages/design-system/src/terminal-markdown/parser/frontmatter.ts"() {
+    "use strict";
+    FrontmatterParseError = class extends Error {
+    };
+    YamlSubsetParser = class {
+      lines;
+      position = 0;
+      constructor(yamlBlock) {
+        this.lines = tokenizeYamlBlock(yamlBlock);
+      }
+      parse() {
+        this.skipBlankLines();
+        if (this.position >= this.lines.length) {
+          return {};
+        }
+        return this.parseObject(0);
+      }
+      parseObject(expectedIndent) {
+        const result = {};
+        while (true) {
+          this.skipBlankLines();
+          const line = this.lines[this.position];
+          if (line === void 0) {
+            break;
+          }
+          if (line.indent < expectedIndent) {
+            break;
+          }
+          if (line.indent !== expectedIndent || isArrayItem(line.content)) {
+            throw new FrontmatterParseError("Invalid object indentation.");
+          }
+          const entry = parseKeyValue(line.content);
+          if (entry === null || hasOwn(result, entry.key)) {
+            throw new FrontmatterParseError("Invalid mapping entry.");
+          }
+          this.position += 1;
+          result[entry.key] = this.readEntryValue(entry, expectedIndent);
+        }
+        return result;
+      }
+      parseArray(expectedIndent) {
+        const result = [];
+        while (true) {
+          this.skipBlankLines();
+          const line = this.lines[this.position];
+          if (line === void 0) {
+            break;
+          }
+          if (line.indent < expectedIndent) {
+            break;
+          }
+          if (line.indent !== expectedIndent) {
+            throw new FrontmatterParseError("Invalid array indentation.");
+          }
+          const item = parseArrayItem(line.content);
+          if (item === null) {
+            throw new FrontmatterParseError("Invalid array item.");
+          }
+          this.position += 1;
+          if (item.length > 0) {
+            result.push(parseScalar(item));
+            continue;
+          }
+          const nestedLine = this.peekMeaningfulLine();
+          if (nestedLine === void 0 || nestedLine.indent <= expectedIndent) {
+            result.push(null);
+            continue;
+          }
+          result.push(
+            isArrayItem(nestedLine.content) ? this.parseArray(nestedLine.indent) : this.parseObject(nestedLine.indent)
+          );
+        }
+        return result;
+      }
+      readEntryValue(entry, currentIndent) {
+        if (entry.value !== void 0) {
+          return parseScalar(entry.value);
+        }
+        const nestedLine = this.peekMeaningfulLine();
+        if (nestedLine === void 0 || nestedLine.indent <= currentIndent) {
+          return null;
+        }
+        return isArrayItem(nestedLine.content) ? this.parseArray(nestedLine.indent) : this.parseObject(nestedLine.indent);
+      }
+      peekMeaningfulLine() {
+        let index = this.position;
+        while (index < this.lines.length) {
+          const line = this.lines[index];
+          if (line.content.length > 0) {
+            return line;
+          }
+          index += 1;
+        }
+        return void 0;
+      }
+      skipBlankLines() {
+        while (this.position < this.lines.length && this.lines[this.position].content.length === 0) {
+          this.position += 1;
+        }
+      }
+    };
+  }
+});
+
+// packages/design-system/src/terminal-markdown/parser/inline.ts
+function parseInline(raw, options = {}) {
+  const nodes = [];
+  const delimiters = [];
+  const footnoteLabels = options.footnoteLabels;
+  const allowLiteralAutolinks = options.allowLiteralAutolinks ?? true;
+  let textBuffer = "";
+  let index = 0;
+  const flushText = () => {
+    if (textBuffer.length === 0) {
+      return;
+    }
+    nodes.push({ type: "text", value: textBuffer });
+    textBuffer = "";
+  };
+  while (index < raw.length) {
+    const char = raw[index];
+    if (char === "\\" && index + 1 < raw.length && isEscapable(raw[index + 1])) {
+      textBuffer += raw[index + 1];
+      index += 2;
+      continue;
+    }
+    if (char === "`") {
+      const code = parseInlineCode(raw, index);
+      if (code !== null) {
+        flushText();
+        nodes.push(code.node);
+        index = code.end;
+        continue;
+      }
+    }
+    if (char === "!" && index + 1 < raw.length && raw[index + 1] === "[") {
+      const image = parseImage(raw, index);
+      if (image !== null) {
+        flushText();
+        nodes.push(image.node);
+        index = image.end;
+        continue;
+      }
+    }
+    if (char === "[") {
+      const footnoteReference = parseFootnoteReference(raw, index, footnoteLabels);
+      if (footnoteReference !== null) {
+        flushText();
+        nodes.push(footnoteReference.node);
+        index = footnoteReference.end;
+        continue;
+      }
+      const link = parseLink(raw, index, footnoteLabels);
+      if (link !== null) {
+        flushText();
+        nodes.push(link.node);
+        index = link.end;
+        continue;
+      }
+    }
+    if (char === "<") {
+      const autolink = parseAutolink(raw, index);
+      if (autolink !== null) {
+        flushText();
+        nodes.push(autolink.node);
+        index = autolink.end;
+        continue;
+      }
+      const html = parseInlineHtmlTag(raw, index);
+      if (html !== null) {
+        flushText();
+        nodes.push(html.node);
+        index = html.end;
+        continue;
+      }
+    }
+    if (char === "\n") {
+      if (textBuffer.endsWith("\\")) {
+        textBuffer = textBuffer.slice(0, -1);
+        flushText();
+        nodes.push({ type: "break" });
+        index += 1;
+        continue;
+      }
+      const trailingSpaceStart = findTrailingHardBreakSpaceStart(textBuffer);
+      if (trailingSpaceStart !== -1) {
+        textBuffer = textBuffer.slice(0, trailingSpaceStart);
+        flushText();
+        nodes.push({ type: "break" });
+        index += 1;
+        continue;
+      }
+    }
+    if (allowLiteralAutolinks) {
+      const literalAutolink = parseLiteralAutolink(raw, index);
+      if (literalAutolink !== null) {
+        flushText();
+        nodes.push(literalAutolink.node);
+        index = literalAutolink.end;
+        continue;
+      }
+    }
+    if (char === "*" || char === "_" || char === "~") {
+      const delimiter = parseDelimiter(raw, index, char);
+      if (delimiter !== null) {
+        flushText();
+        const node = {
+          type: "text",
+          value: raw.slice(index, index + delimiter.length)
+        };
+        nodes.push(node);
+        delimiters.push({
+          ...delimiter,
+          node,
+          position: nodes.length - 1
+        });
+        index += delimiter.length;
+        continue;
+      }
+    }
+    textBuffer += char;
+    index += 1;
+  }
+  flushText();
+  if (delimiters.length === 0) {
+    return normalizeInlineNodes(nodes);
+  }
+  const pairs = matchDelimiterPairs(delimiters);
+  if (pairs.length === 0) {
+    return normalizeInlineNodes(nodes);
+  }
+  return buildInlineNodes(nodes, delimiters, pairs);
+}
+function parseDelimiter(input, start, marker) {
+  const length = readRunLength(input, start, marker);
+  const before = start === 0 ? null : input[start - 1];
+  const after = start + length >= input.length ? null : input[start + length];
+  const leftFlanking = !isDelimiterWhitespace(after) && (!isDelimiterPunctuation(after) || isDelimiterWhitespace(before) || isDelimiterPunctuation(before));
+  const rightFlanking = !isDelimiterWhitespace(before) && (!isDelimiterPunctuation(before) || isDelimiterWhitespace(after) || isDelimiterPunctuation(after));
+  if (marker === "~") {
+    if (length < 2) {
+      return null;
+    }
+    return {
+      marker,
+      length,
+      canOpen: leftFlanking,
+      canClose: rightFlanking
+    };
+  }
+  if (marker === "_") {
+    return {
+      marker,
+      length,
+      canOpen: leftFlanking && (!rightFlanking || isDelimiterPunctuation(before)),
+      canClose: rightFlanking && (!leftFlanking || isDelimiterPunctuation(after))
+    };
+  }
+  return {
+    marker,
+    length,
+    canOpen: leftFlanking,
+    canClose: rightFlanking
+  };
+}
+function matchDelimiterPairs(delimiters) {
+  const pairs = [];
+  const previous = delimiters.map((_2, index) => index - 1);
+  const next = delimiters.map((_2, index) => index + 1 < delimiters.length ? index + 1 : -1);
+  const active = delimiters.map(() => true);
+  let sequence = 0;
+  let closerIndex = 0;
+  const unlinkDelimiter = (index) => {
+    if (!active[index]) {
+      return;
+    }
+    const previousIndex = previous[index];
+    const nextIndex = next[index];
+    if (previousIndex !== -1) {
+      next[previousIndex] = nextIndex;
+    }
+    if (nextIndex !== -1) {
+      previous[nextIndex] = previousIndex;
+    }
+    active[index] = false;
+  };
+  const pruneDelimiter = (index) => {
+    const delimiter = delimiters[index];
+    if (delimiter.length === 0) {
+      unlinkDelimiter(index);
+      return;
+    }
+    if (delimiter.marker === "~" && delimiter.length < 2) {
+      delimiter.canOpen = false;
+      delimiter.canClose = false;
+      unlinkDelimiter(index);
+    }
+  };
+  while (closerIndex !== -1) {
+    const closer = delimiters[closerIndex];
+    if (!closer.canClose || closer.length === 0) {
+      closerIndex = next[closerIndex];
+      continue;
+    }
+    const openerIndex = findMatchingOpener(delimiters, previous, closerIndex);
+    if (openerIndex === null) {
+      const nextCloserIndex = next[closerIndex];
+      if (!closer.canOpen) {
+        unlinkDelimiter(closerIndex);
+      }
+      closerIndex = nextCloserIndex;
+      continue;
+    }
+    const opener = delimiters[openerIndex];
+    const pairLength = getPairLength(opener, closer);
+    if (pairLength === 0 || opener.position + 1 >= closer.position) {
+      closerIndex = next[closerIndex];
+      continue;
+    }
+    pairs.push({
+      opener,
+      closer,
+      kind: getPairKind(opener.marker, pairLength),
+      sequence
+    });
+    opener.length -= pairLength;
+    closer.length -= pairLength;
+    let trappedIndex = next[openerIndex];
+    while (trappedIndex !== -1 && trappedIndex !== closerIndex) {
+      const nextTrappedIndex = next[trappedIndex];
+      unlinkDelimiter(trappedIndex);
+      trappedIndex = nextTrappedIndex;
+    }
+    pruneDelimiter(openerIndex);
+    pruneDelimiter(closerIndex);
+    if (!active[closerIndex] || !closer.canClose || closer.length === 0) {
+      closerIndex = next[closerIndex];
+    }
+    sequence += 1;
+  }
+  return pairs;
+}
+function findMatchingOpener(delimiters, previous, closerIndex) {
+  const closer = delimiters[closerIndex];
+  let openerIndex = previous[closerIndex];
+  while (openerIndex !== -1) {
+    const opener = delimiters[openerIndex];
+    if (opener.marker === closer.marker && opener.canOpen && opener.length > 0 && !violatesMultipleOfThreeRule(opener, closer)) {
+      return openerIndex;
+    }
+    openerIndex = previous[openerIndex];
+  }
+  return null;
+}
+function violatesMultipleOfThreeRule(opener, closer) {
+  if (opener.marker === "~") {
+    return false;
+  }
+  if (!opener.canClose || !closer.canOpen) {
+    return false;
+  }
+  return (opener.length + closer.length) % 3 === 0 && (opener.length % 3 !== 0 || closer.length % 3 !== 0);
+}
+function getPairLength(opener, closer) {
+  if (opener.marker === "~") {
+    return opener.length >= 2 && closer.length >= 2 ? 2 : 0;
+  }
+  return opener.length >= 2 && closer.length >= 2 ? 2 : 1;
+}
+function getPairKind(marker, pairLength) {
+  if (marker === "~") {
+    return "strikethrough";
+  }
+  return pairLength === 2 ? "strong" : "emphasis";
+}
+function buildInlineNodes(nodes, delimiters, pairs) {
+  const delimiterEntries = /* @__PURE__ */ new Map();
+  for (const delimiter of delimiters) {
+    delimiterEntries.set(delimiter.node, {
+      delimiter,
+      opens: [],
+      closes: []
+    });
+  }
+  for (const pair of pairs) {
+    delimiterEntries.get(pair.opener.node)?.opens.push(pair);
+    delimiterEntries.get(pair.closer.node)?.closes.push(pair);
+  }
+  const root = [];
+  const stack = [{ children: root }];
+  const appendNode = (node) => {
+    stack[stack.length - 1]?.children.push(node);
+  };
+  for (const node of nodes) {
+    if (node.type !== "text") {
+      appendNode(node);
+      continue;
+    }
+    const delimiterEntry = delimiterEntries.get(node);
+    if (delimiterEntry === void 0) {
+      appendNode(node);
+      continue;
+    }
+    delimiterEntry.closes.sort((left, right) => left.sequence - right.sequence);
+    for (const pair of delimiterEntry.closes) {
+      const current = stack[stack.length - 1];
+      if (current?.pair === pair) {
+        stack.pop();
+      }
+    }
+    if (delimiterEntry.delimiter.length > 0) {
+      appendNode({
+        type: "text",
+        value: delimiterEntry.delimiter.marker.repeat(delimiterEntry.delimiter.length)
+      });
+    }
+    delimiterEntry.opens.sort((left, right) => right.sequence - left.sequence);
+    for (const pair of delimiterEntry.opens) {
+      const wrapper = createDelimiterNode(pair.kind);
+      appendNode(wrapper);
+      stack.push({ pair, children: wrapper.children });
+    }
+  }
+  return normalizeInlineNodes(root);
+}
+function createDelimiterNode(kind) {
+  return { type: kind, children: [] };
+}
+function normalizeInlineNodes(nodes) {
+  const normalized = [];
+  for (const node of nodes) {
+    const nextNode = normalizeInlineNode(node);
+    if (nextNode === null) {
+      continue;
+    }
+    const previousNode = normalized[normalized.length - 1];
+    if (previousNode?.type === "text" && nextNode.type === "text") {
+      previousNode.value += nextNode.value;
+      continue;
+    }
+    normalized.push(nextNode);
+  }
+  return normalized;
+}
+function normalizeInlineNode(node) {
+  if (node.type === "text") {
+    return node.value.length === 0 ? null : node;
+  }
+  if (node.type === "emphasis" || node.type === "strong" || node.type === "strikethrough" || node.type === "link") {
+    return { ...node, children: normalizeInlineNodes(node.children) };
+  }
+  return node;
+}
+function parseInlineCode(input, start) {
+  const fenceLength = readRunLength(input, start, "`");
+  let index = start + fenceLength;
+  while (index < input.length) {
+    if (input[index] !== "`") {
+      index += 1;
+      continue;
+    }
+    const closingFenceLength = readRunLength(input, index, "`");
+    if (closingFenceLength === fenceLength) {
+      return {
+        node: {
+          type: "inlineCode",
+          value: input.slice(start + fenceLength, index)
+        },
+        end: index + fenceLength
+      };
+    }
+    index += closingFenceLength;
+  }
+  return null;
+}
+function parseLink(input, start, footnoteLabels) {
+  const label = parseBracketedLabel(input, start);
+  if (label === null || label.end >= input.length || input[label.end] !== "(") {
+    return null;
+  }
+  const destination = parseLinkDestination(input, label.end);
+  if (destination === null) {
+    return null;
+  }
+  return {
+    node: {
+      type: "link",
+      url: destination.url,
+      ...destination.title === void 0 ? {} : { title: destination.title },
+      children: parseInline(label.value, {
+        footnoteLabels,
+        allowLiteralAutolinks: false
+      })
+    },
+    end: destination.end
+  };
+}
+function parseImage(input, start) {
+  const label = parseBracketedLabel(input, start + 1);
+  if (label === null || label.end >= input.length || input[label.end] !== "(") {
+    return null;
+  }
+  const destination = parseLinkDestination(input, label.end);
+  if (destination === null) {
+    return null;
+  }
+  return {
+    node: {
+      type: "image",
+      url: destination.url,
+      alt: decodeEscapes(label.value),
+      ...destination.title === void 0 ? {} : { title: destination.title }
+    },
+    end: destination.end
+  };
+}
+function parseBracketedLabel(input, start) {
+  if (start >= input.length || input[start] !== "[") {
+    return null;
+  }
+  let depth = 1;
+  let index = start + 1;
+  while (index < input.length) {
+    const char = input[index];
+    if (char === "\\" && index + 1 < input.length) {
+      index += 2;
+      continue;
+    }
+    if (char === "`") {
+      const code = parseInlineCode(input, index);
+      if (code !== null) {
+        index = code.end;
+        continue;
+      }
+    }
+    if (char === "[") {
+      depth += 1;
+      index += 1;
+      continue;
+    }
+    if (char === "]") {
+      depth -= 1;
+      if (depth === 0) {
+        return {
+          value: input.slice(start + 1, index),
+          end: index + 1
+        };
+      }
+    }
+    index += 1;
+  }
+  return null;
+}
+function parseLinkDestination(input, openParenIndex) {
+  let depth = 1;
+  let quote = null;
+  let index = openParenIndex + 1;
+  while (index < input.length) {
+    const char = input[index];
+    if (quote !== null) {
+      if (char === "\\" && index + 1 < input.length) {
+        index += 2;
+        continue;
+      }
+      if (char === quote) {
+        quote = null;
+      }
+      index += 1;
+      continue;
+    }
+    if (char === "\\" && index + 1 < input.length && isEscapable(input[index + 1])) {
+      index += 2;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      index += 1;
+      continue;
+    }
+    if (char === "(") {
+      depth += 1;
+      index += 1;
+      continue;
+    }
+    if (char === ")") {
+      depth -= 1;
+      if (depth === 0) {
+        const content = input.slice(openParenIndex + 1, index);
+        const parsed = parseLinkDestinationContent(content);
+        return {
+          ...parsed,
+          end: index + 1
+        };
+      }
+    }
+    index += 1;
+  }
+  return null;
+}
+function parseLinkDestinationContent(content) {
+  const trimmedEnd = trimAsciiWhitespaceEndIndex(content);
+  if (trimmedEnd === 0) {
+    return { url: "" };
+  }
+  const quote = content[trimmedEnd - 1];
+  if (quote === '"' || quote === "'") {
+    const titleStart = findTrailingQuotedSegmentStart(content, trimmedEnd, quote);
+    if (titleStart !== -1) {
+      let separatorStart = titleStart;
+      while (separatorStart > 0 && isAsciiWhitespace(content[separatorStart - 1])) {
+        separatorStart -= 1;
+      }
+      if (separatorStart < titleStart) {
+        return {
+          url: decodeEscapes(trimAsciiWhitespace2(content.slice(0, separatorStart))),
+          title: decodeEscapes(content.slice(titleStart + 1, trimmedEnd - 1))
+        };
+      }
+    }
+  }
+  return { url: decodeEscapes(trimAsciiWhitespace2(content.slice(0, trimmedEnd))) };
+}
+function findTrailingQuotedSegmentStart(content, end, quote) {
+  let index = end - 2;
+  while (index >= 0) {
+    if (content[index] === quote && !isEscaped(content, index)) {
+      return index;
+    }
+    index -= 1;
+  }
+  return -1;
+}
+function parseAutolink(input, start) {
+  let index = start + 1;
+  while (index < input.length && input[index] !== ">") {
+    const char = input[index];
+    if (char === "<" || char === "\n" || char === " " || char === "	") {
+      return null;
+    }
+    index += 1;
+  }
+  if (index >= input.length || index === start + 1) {
+    return null;
+  }
+  const url = input.slice(start + 1, index);
+  if (!isAutolinkUrl(url)) {
+    return null;
+  }
+  return {
+    node: {
+      type: "link",
+      url,
+      children: [{ type: "text", value: url }]
+    },
+    end: index + 1
+  };
+}
+function parseFootnoteReference(input, start, footnoteLabels) {
+  if (footnoteLabels === void 0 || start + 3 >= input.length || input[start] !== "[" || input[start + 1] !== "^") {
+    return null;
+  }
+  let labelEnd = start + 2;
+  while (labelEnd < input.length && input[labelEnd] !== "]") {
+    if (!isFootnoteLabelChar(input[labelEnd])) {
+      return null;
+    }
+    labelEnd += 1;
+  }
+  if (labelEnd === start + 2 || labelEnd >= input.length) {
+    return null;
+  }
+  const label = input.slice(start + 2, labelEnd);
+  if (!footnoteLabels.has(label)) {
+    return null;
+  }
+  return {
+    node: { type: "footnoteReference", label },
+    end: labelEnd + 1
+  };
+}
+function parseLiteralAutolink(input, start) {
+  if (!isLiteralAutolinkBoundaryBefore(input, start)) {
+    return null;
+  }
+  const urlLiteral = parseLiteralUrlAutolink(input, start);
+  if (urlLiteral !== null) {
+    return createLiteralAutolinkNode(urlLiteral.text, urlLiteral.url, urlLiteral.end);
+  }
+  const wwwLiteral = parseLiteralWwwAutolink(input, start);
+  if (wwwLiteral !== null) {
+    return createLiteralAutolinkNode(wwwLiteral.text, `http://${wwwLiteral.text}`, wwwLiteral.end);
+  }
+  const emailLiteral = parseLiteralEmailAutolink(input, start);
+  if (emailLiteral !== null) {
+    return createLiteralAutolinkNode(
+      emailLiteral.text,
+      `mailto:${emailLiteral.text}`,
+      emailLiteral.end
+    );
+  }
+  return null;
+}
+function createLiteralAutolinkNode(text4, url, end) {
+  return {
+    node: {
+      type: "link",
+      url,
+      children: [{ type: "text", value: text4 }]
+    },
+    end
+  };
+}
+function parseLiteralUrlAutolink(input, start) {
+  const hasHttp = input.startsWith("http://", start);
+  const hasHttps = input.startsWith("https://", start);
+  if (!hasHttp && !hasHttps) {
+    return null;
+  }
+  const end = scanLiteralAutolinkEnd(input, start);
+  const text4 = trimLiteralAutolinkText(input.slice(start, end));
+  const prefixLength = hasHttps ? "https://".length : "http://".length;
+  if (text4.length <= prefixLength) {
+    return null;
+  }
+  return { text: text4, url: text4, end: start + text4.length };
+}
+function parseLiteralWwwAutolink(input, start) {
+  if (!input.startsWith("www.", start)) {
+    return null;
+  }
+  const end = scanLiteralAutolinkEnd(input, start);
+  const text4 = trimLiteralAutolinkText(input.slice(start, end));
+  if (!hasDotAfterPrefix(text4, 4)) {
+    return null;
+  }
+  return { text: text4, end: start + text4.length };
+}
+function parseLiteralEmailAutolink(input, start) {
+  if (!isEmailLocalPartChar(input[start] ?? "")) {
+    return null;
+  }
+  const end = scanLiteralAutolinkEnd(input, start);
+  const text4 = trimLiteralAutolinkText(input.slice(start, end));
+  if (!isValidLiteralEmail(text4)) {
+    return null;
+  }
+  return { text: text4, end: start + text4.length };
+}
+function parseInlineHtmlTag(input, start) {
+  if (input[start] !== "<") {
+    return null;
+  }
+  let index = start + 1;
+  let closing = false;
+  if (index < input.length && input[index] === "/") {
+    closing = true;
+    index += 1;
+  }
+  if (index >= input.length || !isAsciiLetter(input[index])) {
+    return null;
+  }
+  index += 1;
+  while (index < input.length && isHtmlTagNameChar(input[index])) {
+    index += 1;
+  }
+  const tagName = input.slice(start + (closing ? 2 : 1), index).toLowerCase();
+  if (!INLINE_HTML_TAGS.has(tagName)) {
+    return null;
+  }
+  if (closing) {
+    index = skipHtmlWhitespace(input, index);
+    if (index >= input.length || input[index] !== ">") {
+      return null;
+    }
+    return {
+      node: { type: "html", value: input.slice(start, index + 1) },
+      end: index + 1
+    };
+  }
+  while (index < input.length) {
+    index = skipHtmlWhitespace(input, index);
+    if (index >= input.length) {
+      return null;
+    }
+    if (input[index] === ">") {
+      return {
+        node: { type: "html", value: input.slice(start, index + 1) },
+        end: index + 1
+      };
+    }
+    if (input[index] === "/") {
+      const selfClosingEnd = skipHtmlWhitespace(input, index + 1);
+      if (selfClosingEnd >= input.length || input[selfClosingEnd] !== ">") {
+        return null;
+      }
+      return {
+        node: { type: "html", value: input.slice(start, selfClosingEnd + 1) },
+        end: selfClosingEnd + 1
+      };
+    }
+    if (!isHtmlAttributeNameStartChar(input[index])) {
+      return null;
+    }
+    index += 1;
+    while (index < input.length && isHtmlAttributeNameChar(input[index])) {
+      index += 1;
+    }
+    index = skipHtmlWhitespace(input, index);
+    if (index >= input.length || input[index] !== "=") {
+      continue;
+    }
+    index = skipHtmlWhitespace(input, index + 1);
+    if (index >= input.length) {
+      return null;
+    }
+    const quote = input[index];
+    if (quote === '"' || quote === "'") {
+      index += 1;
+      while (index < input.length && input[index] !== quote) {
+        index += 1;
+      }
+      if (index >= input.length) {
+        return null;
+      }
+      index += 1;
+      continue;
+    }
+    while (index < input.length && !isHtmlWhitespace(input[index]) && input[index] !== ">") {
+      const char = input[index];
+      if (char === '"' || char === "'" || char === "<" || char === "=" || char === "`") {
+        return null;
+      }
+      index += 1;
+    }
+  }
+  return null;
+}
+function decodeEscapes(value) {
+  let result = "";
+  let index = 0;
+  while (index < value.length) {
+    if (value[index] === "\\" && index + 1 < value.length && isEscapable(value[index + 1])) {
+      result += value[index + 1];
+      index += 2;
+      continue;
+    }
+    result += value[index];
+    index += 1;
+  }
+  return result;
+}
+function findTrailingHardBreakSpaceStart(value) {
+  let start = value.length;
+  while (start > 0 && (value[start - 1] === " " || value[start - 1] === "	")) {
+    start -= 1;
+  }
+  return value.length - start >= 2 ? start : -1;
+}
+function readRunLength(input, start, char) {
+  let index = start;
+  while (index < input.length && input[index] === char) {
+    index += 1;
+  }
+  return index - start;
+}
+function trimAsciiWhitespace2(value) {
+  const start = trimAsciiWhitespaceStartIndex(value);
+  const end = trimAsciiWhitespaceEndIndex(value);
+  return value.slice(start, end);
+}
+function trimAsciiWhitespaceStartIndex(value) {
+  let index = 0;
+  while (index < value.length && isAsciiWhitespace(value[index])) {
+    index += 1;
+  }
+  return index;
+}
+function trimAsciiWhitespaceEndIndex(value) {
+  let index = value.length;
+  while (index > 0 && isAsciiWhitespace(value[index - 1])) {
+    index -= 1;
+  }
+  return index;
+}
+function isAutolinkUrl(value) {
+  if (value.length < 3 || !isAsciiLetter(value[0])) {
+    return false;
+  }
+  let index = 1;
+  while (index < value.length) {
+    const char = value[index];
+    if (char === ":") {
+      return index >= 2;
+    }
+    if (!isAsciiLetter(char) && !isDigit(char) && char !== "+" && char !== "." && char !== "-") {
+      return false;
+    }
+    index += 1;
+  }
+  return false;
+}
+function scanLiteralAutolinkEnd(input, start) {
+  let index = start;
+  while (index < input.length) {
+    const char = input[index];
+    if (char === "\n" || isAsciiWhitespace(char) || char === "<") {
+      break;
+    }
+    index += 1;
+  }
+  return index;
+}
+function trimLiteralAutolinkText(value) {
+  let end = value.length;
+  while (end > 0) {
+    const lastChar = value[end - 1];
+    if (lastChar === "." || lastChar === "," || lastChar === ":" || lastChar === ";" || lastChar === "!" || lastChar === "?") {
+      end -= 1;
+      continue;
+    }
+    if (lastChar === ")" && hasMoreClosersThanOpeners(value.slice(0, end), "(", ")") || lastChar === "]" && hasMoreClosersThanOpeners(value.slice(0, end), "[", "]") || lastChar === "}" && hasMoreClosersThanOpeners(value.slice(0, end), "{", "}")) {
+      end -= 1;
+      continue;
+    }
+    break;
+  }
+  return value.slice(0, end);
+}
+function hasMoreClosersThanOpeners(value, opener, closer) {
+  let balance = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    if (value[index] === opener) {
+      balance += 1;
+      continue;
+    }
+    if (value[index] === closer) {
+      balance -= 1;
+    }
+  }
+  return balance < 0;
+}
+function isLiteralAutolinkBoundaryBefore(input, start) {
+  if (start === 0) {
+    return true;
+  }
+  const previous = input[start - 1];
+  if (previous === "(" && start >= 2 && input[start - 2] === "]") {
+    return false;
+  }
+  return !isAsciiLetter(previous) && !isDigit(previous) && previous !== "_" && previous !== "." && previous !== "+" && previous !== "-" && previous !== "@" && previous !== "/";
+}
+function hasDotAfterPrefix(value, prefixLength) {
+  if (value.length <= prefixLength) {
+    return false;
+  }
+  for (let index = prefixLength; index < value.length; index += 1) {
+    if (value[index] === ".") {
+      return true;
+    }
+  }
+  return false;
+}
+function isValidLiteralEmail(value) {
+  const atIndex = value.indexOf("@");
+  if (atIndex <= 0 || atIndex === value.length - 1 || value.indexOf("@", atIndex + 1) !== -1) {
+    return false;
+  }
+  const localPart = value.slice(0, atIndex);
+  const domain = value.slice(atIndex + 1);
+  if (domain[0] === "." || domain[domain.length - 1] === "." || !hasDotAfterPrefix(domain, 0)) {
+    return false;
+  }
+  for (let index = 0; index < localPart.length; index += 1) {
+    if (!isEmailLocalPartChar(localPart[index])) {
+      return false;
+    }
+  }
+  for (let index = 0; index < domain.length; index += 1) {
+    if (!isEmailDomainChar(domain[index])) {
+      return false;
+    }
+  }
+  return true;
+}
+function isEscaped(value, index) {
+  let slashCount = 0;
+  let cursor = index - 1;
+  while (cursor >= 0 && value[cursor] === "\\") {
+    slashCount += 1;
+    cursor -= 1;
+  }
+  return slashCount % 2 === 1;
+}
+function skipHtmlWhitespace(value, start) {
+  let index = start;
+  while (index < value.length && isHtmlWhitespace(value[index])) {
+    index += 1;
+  }
+  return index;
+}
+function isEscapable(value) {
+  return value === "!" || value === '"' || value === "#" || value === "$" || value === "%" || value === "&" || value === "'" || value === "(" || value === ")" || value === "*" || value === "+" || value === "," || value === "-" || value === "." || value === "/" || value === ":" || value === ";" || value === "<" || value === "=" || value === ">" || value === "?" || value === "@" || value === "[" || value === "\\" || value === "]" || value === "^" || value === "_" || value === "`" || value === "{" || value === "|" || value === "}" || value === "~";
+}
+function isAsciiWhitespace(value) {
+  return value === " " || value === "	";
+}
+function isDelimiterWhitespace(value) {
+  return value === null || /\s/u.test(value);
+}
+function isDelimiterPunctuation(value) {
+  return value !== null && /[\p{P}\p{S}]/u.test(value);
+}
+function isHtmlWhitespace(value) {
+  return value === " " || value === "	";
+}
+function isAsciiLetter(value) {
+  return value >= "a" && value <= "z" || value >= "A" && value <= "Z";
+}
+function isDigit(value) {
+  return value >= "0" && value <= "9";
+}
+function isEmailLocalPartChar(value) {
+  return isAsciiLetter(value) || isDigit(value) || value === "." || value === "_" || value === "%" || value === "+" || value === "-";
+}
+function isEmailDomainChar(value) {
+  return isAsciiLetter(value) || isDigit(value) || value === "." || value === "-";
+}
+function isFootnoteLabelChar(value) {
+  return isAsciiLetter(value) || isDigit(value) || value === "-" || value === "_";
+}
+function isHtmlTagNameChar(value) {
+  return isAsciiLetter(value) || isDigit(value) || value === "-";
+}
+function isHtmlAttributeNameStartChar(value) {
+  return isAsciiLetter(value) || value === ":" || value === "_";
+}
+function isHtmlAttributeNameChar(value) {
+  return isHtmlAttributeNameStartChar(value) || isDigit(value) || value === "-" || value === ".";
+}
+var INLINE_HTML_TAGS;
+var init_inline = __esm({
+  "packages/design-system/src/terminal-markdown/parser/inline.ts"() {
+    "use strict";
+    INLINE_HTML_TAGS = /* @__PURE__ */ new Set([
+      "a",
+      "abbr",
+      "address",
+      "article",
+      "aside",
+      "b",
+      "base",
+      "basefont",
+      "bdi",
+      "bdo",
+      "blockquote",
+      "body",
+      "br",
+      "button",
+      "caption",
+      "center",
+      "cite",
+      "code",
+      "col",
+      "colgroup",
+      "data",
+      "dd",
+      "del",
+      "details",
+      "dfn",
+      "dialog",
+      "div",
+      "dl",
+      "dt",
+      "em",
+      "fieldset",
+      "figcaption",
+      "figure",
+      "footer",
+      "form",
+      "h1",
+      "h2",
+      "h3",
+      "h4",
+      "h5",
+      "h6",
+      "head",
+      "header",
+      "hr",
+      "html",
+      "i",
+      "img",
+      "input",
+      "ins",
+      "kbd",
+      "label",
+      "legend",
+      "li",
+      "link",
+      "main",
+      "mark",
+      "menu",
+      "nav",
+      "ol",
+      "option",
+      "p",
+      "param",
+      "pre",
+      "q",
+      "rp",
+      "rt",
+      "rtc",
+      "ruby",
+      "s",
+      "samp",
+      "search",
+      "section",
+      "small",
+      "span",
+      "strong",
+      "sub",
+      "summary",
+      "sup",
+      "table",
+      "tbody",
+      "td",
+      "tfoot",
+      "th",
+      "thead",
+      "time",
+      "title",
+      "tr",
+      "u",
+      "ul",
+      "var",
+      "wbr"
+    ]);
+  }
+});
+
+// packages/design-system/src/terminal-markdown/parser/block.ts
+function parseBlockDocument(input) {
+  const { frontmatter, body } = extractFrontmatter(input);
+  const children = applyInlineParsing(
+    parseBlocksWithOptions(body, { preferListToThematicBreak: false })
+  );
+  return frontmatter === void 0 ? { children } : { frontmatter, children };
+}
+function parseBlocksWithOptions(input, options) {
+  const state = {
+    input: stripBom2(input),
+    position: 0,
+    preferListToThematicBreak: options.preferListToThematicBreak
+  };
+  const blocks = [];
+  const rules = createBlockRules(state.preferListToThematicBreak);
+  while (state.position < state.input.length) {
+    const line = readLine2(state.input, state.position);
+    if (isBlankLine(line.text)) {
+      state.position = line.nextPosition;
+      continue;
+    }
+    let matchedNode = null;
+    for (const rule of rules) {
+      matchedNode = rule(state);
+      if (matchedNode !== null) {
+        blocks.push(matchedNode);
+        break;
+      }
+    }
+    if (matchedNode !== null) {
+      continue;
+    }
+    blocks.push(parseParagraph(state));
+  }
+  return blocks;
+}
+function applyInlineParsing(nodes) {
+  const footnoteLabels = collectFootnoteLabels(nodes);
+  return nodes.map((node) => applyInlineParsingToNode(node, footnoteLabels));
+}
+function collectFootnoteLabels(nodes) {
+  const labels = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    collectFootnoteLabelsFromNode(node, labels);
+  }
+  return labels;
+}
+function collectFootnoteLabelsFromNode(node, labels) {
+  if (node.type === "footnoteDefinition") {
+    labels.add(node.label);
+  }
+  if (hasBlockChildren(node)) {
+    for (const child of node.children) {
+      collectFootnoteLabelsFromNode(child, labels);
+    }
+  }
+}
+function applyInlineParsingToNode(node, footnoteLabels) {
+  if (node.type === "paragraph" || node.type === "heading" || node.type === "tableCell") {
+    return {
+      ...node,
+      children: applyInlineParsingToTextChildren(node.children, footnoteLabels)
+    };
+  }
+  if (hasBlockChildren(node)) {
+    return {
+      ...node,
+      children: node.children.map((child) => applyInlineParsingToNode(child, footnoteLabels))
+    };
+  }
+  return node;
+}
+function applyInlineParsingToTextChildren(children, footnoteLabels) {
+  let rawText = "";
+  for (const child of children) {
+    if (child.type !== "text") {
+      return children;
+    }
+    rawText += child.value;
+  }
+  return parseInline(rawText, { footnoteLabels });
+}
+function hasBlockChildren(node) {
+  return node.type === "root" || node.type === "blockquote" || node.type === "list" || node.type === "listItem" || node.type === "table" || node.type === "tableRow" || node.type === "alert" || node.type === "footnoteDefinition";
+}
+function createBlockRules(preferListToThematicBreak) {
+  const middleRules = preferListToThematicBreak ? [parseAlert, parseBlockquote, parseList, parseHtmlBlock, parseThematicBreak] : [parseThematicBreak, parseAlert, parseBlockquote, parseList, parseHtmlBlock];
+  return [
+    parseFencedCodeBlock,
+    parseAtxHeading,
+    ...middleRules,
+    parseTable,
+    parseFootnoteDefinition,
+    parseSetextHeading
+  ];
+}
+function parseFencedCodeBlock(state) {
+  const openingLine = readLine2(state.input, state.position);
+  const fence = parseOpeningFence(openingLine.text);
+  if (fence === null) {
+    return null;
+  }
+  state.position = openingLine.nextPosition;
+  const contentLines = [];
+  while (state.position < state.input.length) {
+    const line = readLine2(state.input, state.position);
+    if (isClosingFence(line.text, fence)) {
+      state.position = line.nextPosition;
+      return createCodeNode(fence, contentLines);
+    }
+    contentLines.push(line.text);
+    state.position = line.nextPosition;
+  }
+  return createCodeNode(fence, contentLines);
+}
+function parseAtxHeading(state) {
+  const line = readLine2(state.input, state.position);
+  const heading = parseAtxHeadingLine(line.text);
+  if (heading === null) {
+    return null;
+  }
+  state.position = line.nextPosition;
+  return {
+    type: "heading",
+    depth: heading.depth,
+    children: createTextChildren(heading.text)
+  };
+}
+function parseThematicBreak(state) {
+  const line = readLine2(state.input, state.position);
+  if (!isThematicBreakLine(line.text)) {
+    return null;
+  }
+  state.position = line.nextPosition;
+  return { type: "thematicBreak" };
+}
+function parseSetextHeading(state) {
+  const contentLine = readLine2(state.input, state.position);
+  if (isBlankLine(contentLine.text)) {
+    return null;
+  }
+  if (contentLine.nextPosition >= state.input.length) {
+    return null;
+  }
+  const underlineLine = readLine2(state.input, contentLine.nextPosition);
+  const depth = parseSetextUnderline(underlineLine.text);
+  if (depth === null) {
+    return null;
+  }
+  state.position = underlineLine.nextPosition;
+  return {
+    type: "heading",
+    depth,
+    children: createTextChildren(trimAsciiWhitespace3(contentLine.text))
+  };
+}
+function parseBlockquote(state) {
+  const firstLine = readLine2(state.input, state.position);
+  if (stripBlockquoteMarker(firstLine.text) === null) {
+    return null;
+  }
+  const contentLines = [];
+  while (state.position < state.input.length) {
+    const line = readLine2(state.input, state.position);
+    const content = stripBlockquoteMarker(line.text);
+    if (content === null) {
+      break;
+    }
+    contentLines.push(content);
+    state.position = line.nextPosition;
+  }
+  return {
+    type: "blockquote",
+    children: parseBlocksWithOptions(contentLines.join("\n"), {
+      preferListToThematicBreak: state.preferListToThematicBreak
+    })
+  };
+}
+function parseAlert(state) {
+  const firstLine = readLine2(state.input, state.position);
+  const firstLineContent = stripBlockquoteMarker(firstLine.text);
+  if (firstLineContent === null) {
+    return null;
+  }
+  const alertMarker = parseAlertMarker(firstLineContent);
+  if (alertMarker === null) {
+    return null;
+  }
+  state.position = firstLine.nextPosition;
+  const contentLines = alertMarker.content.length === 0 ? [] : [alertMarker.content];
+  while (state.position < state.input.length) {
+    const line = readLine2(state.input, state.position);
+    const content = stripBlockquoteMarker(line.text);
+    if (content === null) {
+      break;
+    }
+    contentLines.push(content);
+    state.position = line.nextPosition;
+  }
+  return {
+    type: "alert",
+    kind: alertMarker.kind,
+    children: parseBlocksWithOptions(contentLines.join("\n"), {
+      preferListToThematicBreak: state.preferListToThematicBreak
+    })
+  };
+}
+function parseList(state) {
+  const firstLine = readLine2(state.input, state.position);
+  const firstMarker = parseListMarker(firstLine.text);
+  if (firstMarker === null) {
+    return null;
+  }
+  const children = [];
+  const ordered = firstMarker.ordered;
+  const start = firstMarker.start;
+  const indent = firstMarker.indent;
+  while (state.position < state.input.length) {
+    const item = parseListItem(state, {
+      ordered,
+      indent,
+      preferListToThematicBreak: true
+    });
+    if (item === null) {
+      break;
+    }
+    children.push(item);
+  }
+  return {
+    type: "list",
+    ordered,
+    ...ordered && start !== void 0 ? { start } : {},
+    children
+  };
+}
+function parseTable(state) {
+  const table = parseTableAt(state.input, state.position, state.preferListToThematicBreak);
+  if (table === null) {
+    return null;
+  }
+  state.position = table.nextPosition;
+  return {
+    type: "table",
+    align: table.align,
+    children: [
+      createTableRowNode(table.headerCells),
+      ...table.rows.map((row) => createTableRowNode(row))
+    ]
+  };
+}
+function parseHtmlBlock(state) {
+  const firstLine = readLine2(state.input, state.position);
+  const openingTag = parseBlockHtmlTagStart(firstLine.text);
+  if (openingTag === null) {
+    return null;
+  }
+  state.position = firstLine.nextPosition;
+  const lines = [firstLine.text];
+  const isSelfContained = openingTag.closing || openingTag.selfClosing || VOID_BLOCK_HTML_TAGS.has(openingTag.tagName) || containsClosingHtmlTag(firstLine.text, openingTag.tagName, openingTag.tagEnd);
+  if (!isSelfContained) {
+    while (state.position < state.input.length) {
+      const line = readLine2(state.input, state.position);
+      lines.push(line.text);
+      state.position = line.nextPosition;
+      if (containsClosingHtmlTag(line.text, openingTag.tagName)) {
+        break;
+      }
+    }
+  }
+  return { type: "html", value: lines.join("\n") };
+}
+function parseFootnoteDefinition(state) {
+  const firstLine = readLine2(state.input, state.position);
+  const definition = parseFootnoteDefinitionMarker(firstLine.text);
+  if (definition === null) {
+    return null;
+  }
+  state.position = firstLine.nextPosition;
+  const continuationLines = [];
+  const pendingBlankLines = [];
+  while (state.position < state.input.length) {
+    const line = readLine2(state.input, state.position);
+    if (isBlankLine(line.text)) {
+      pendingBlankLines.push("");
+      state.position = line.nextPosition;
+      continue;
+    }
+    const strippedLine = stripIndent(line.text, 4);
+    if (strippedLine === null) {
+      break;
+    }
+    state.position = line.nextPosition;
+    continuationLines.push(...pendingBlankLines, strippedLine);
+    pendingBlankLines.length = 0;
+  }
+  return {
+    type: "footnoteDefinition",
+    label: definition.label,
+    children: parseListItemChildren(
+      firstLine.text.slice(definition.contentStart),
+      continuationLines,
+      state.preferListToThematicBreak
+    )
+  };
+}
+function parseParagraph(state) {
+  const lines = [];
+  while (state.position < state.input.length) {
+    const line = readLine2(state.input, state.position);
+    if (isBlankLine(line.text)) {
+      break;
+    }
+    if (lines.length > 0 && startsBlockAt(state.input, state.position, state.preferListToThematicBreak)) {
+      break;
+    }
+    lines.push(line.text);
+    state.position = line.nextPosition;
+  }
+  return {
+    type: "paragraph",
+    children: [{ type: "text", value: lines.join("\n") }]
+  };
+}
+function createCodeNode(fence, contentLines) {
+  return {
+    type: "code",
+    ...fence.lang === void 0 ? {} : { lang: fence.lang },
+    ...fence.meta === void 0 ? {} : { meta: fence.meta },
+    value: contentLines.join("\n")
+  };
+}
+function createTextChildren(value) {
+  return value.length === 0 ? [] : [{ type: "text", value }];
+}
+function createTableRowNode(values) {
+  return {
+    type: "tableRow",
+    children: values.map((value) => ({
+      type: "tableCell",
+      children: createTextChildren(value)
+    }))
+  };
+}
+function startsBlockAt(input, position, preferListToThematicBreak) {
+  const line = readLine2(input, position);
+  if (startsSimpleBlock(line.text, preferListToThematicBreak)) {
+    return true;
+  }
+  if (line.nextPosition >= input.length) {
+    return false;
+  }
+  const nextLine = readLine2(input, line.nextPosition);
+  return parseTableHeaderAndSeparator(line.text, nextLine.text) !== null;
+}
+function startsBlockInLines(lines, lineIndex, preferListToThematicBreak) {
+  const line = lines[lineIndex];
+  if (startsSimpleBlock(line, preferListToThematicBreak)) {
+    return true;
+  }
+  return lineIndex + 1 < lines.length && parseTableHeaderAndSeparator(line, lines[lineIndex + 1]) !== null;
+}
+function startsSimpleBlock(line, preferListToThematicBreak) {
+  if (parseOpeningFence(line) !== null || parseAtxHeadingLine(line) !== null || parseBlockHtmlTagStart(line) !== null || parseFootnoteDefinitionMarker(line) !== null) {
+    return true;
+  }
+  if (stripBlockquoteMarker(line) !== null) {
+    return true;
+  }
+  if (preferListToThematicBreak) {
+    return parseListMarker(line) !== null || isThematicBreakLine(line);
+  }
+  return isThematicBreakLine(line) || parseListMarker(line) !== null;
+}
+function parseOpeningFence(line) {
+  const fenceStart = skipLeadingBlockIndent(line);
+  if (fenceStart === -1 || fenceStart >= line.length) {
+    return null;
+  }
+  const char = line[fenceStart];
+  if (char !== "`" && char !== "~") {
+    return null;
+  }
+  let fenceEnd = fenceStart;
+  while (fenceEnd < line.length && line[fenceEnd] === char) {
+    fenceEnd += 1;
+  }
+  const fenceLength = fenceEnd - fenceStart;
+  if (fenceLength < 3) {
+    return null;
+  }
+  const info2 = trimAsciiWhitespace3(line.slice(fenceEnd));
+  if (info2.length === 0) {
+    return { char, length: fenceLength };
+  }
+  const languageEnd = findWhitespaceIndex(info2);
+  const lang = languageEnd === -1 ? info2 : info2.slice(0, languageEnd);
+  const meta = languageEnd === -1 ? void 0 : trimAsciiWhitespaceStart2(info2.slice(languageEnd));
+  return {
+    char,
+    length: fenceLength,
+    lang,
+    ...meta === void 0 || meta.length === 0 ? {} : { meta }
+  };
+}
+function parseAtxHeadingLine(line) {
+  const markerStart = skipLeadingBlockIndent(line);
+  if (markerStart === -1 || markerStart >= line.length || line[markerStart] !== "#") {
+    return null;
+  }
+  let markerEnd = markerStart;
+  while (markerEnd < line.length && line[markerEnd] === "#") {
+    markerEnd += 1;
+  }
+  const depth = markerEnd - markerStart;
+  if (depth < 1 || depth > 6) {
+    return null;
+  }
+  if (markerEnd < line.length && line[markerEnd] !== " " && line[markerEnd] !== "	") {
+    return null;
+  }
+  const rawContent = trimAsciiWhitespaceStart2(line.slice(markerEnd));
+  return {
+    depth,
+    text: stripClosingHeadingSequence(rawContent)
+  };
+}
+function stripClosingHeadingSequence(value) {
+  const trimmedValue = trimAsciiWhitespaceEnd2(value);
+  if (trimmedValue.length === 0) {
+    return "";
+  }
+  let hashStart = trimmedValue.length;
+  while (hashStart > 0 && trimmedValue[hashStart - 1] === "#") {
+    hashStart -= 1;
+  }
+  if (hashStart === trimmedValue.length) {
+    return trimmedValue;
+  }
+  if (hashStart === 0) {
+    return "";
+  }
+  const prefixEnd = hashStart - 1;
+  if (trimmedValue[prefixEnd] !== " " && trimmedValue[prefixEnd] !== "	") {
+    return trimmedValue;
+  }
+  return trimAsciiWhitespaceEnd2(trimmedValue.slice(0, prefixEnd));
+}
+function isClosingFence(line, fence) {
+  const fenceStart = skipLeadingBlockIndent(line);
+  if (fenceStart === -1 || fenceStart >= line.length) {
+    return false;
+  }
+  let index = fenceStart;
+  while (index < line.length && line[index] === fence.char) {
+    index += 1;
+  }
+  if (index - fenceStart < fence.length) {
+    return false;
+  }
+  if (fenceStart === index) {
+    return false;
+  }
+  for (let restIndex = index; restIndex < line.length; restIndex += 1) {
+    const char = line[restIndex];
+    if (char !== " " && char !== "	") {
+      return false;
+    }
+  }
+  return true;
+}
+function isThematicBreakLine(line) {
+  const start = skipLeadingBlockIndent(line);
+  if (start === -1 || start >= line.length) {
+    return false;
+  }
+  const marker = line[start];
+  if (marker !== "-" && marker !== "*" && marker !== "_") {
+    return false;
+  }
+  let markerCount = 0;
+  for (let index = start; index < line.length; index += 1) {
+    const char = line[index];
+    if (char === marker) {
+      markerCount += 1;
+      continue;
+    }
+    if (char === " " || char === "	") {
+      continue;
+    }
+    return false;
+  }
+  return markerCount >= 3;
+}
+function parseSetextUnderline(line) {
+  const start = skipLeadingBlockIndent(line);
+  if (start === -1 || start >= line.length) {
+    return null;
+  }
+  const marker = line[start];
+  if (marker !== "=" && marker !== "-") {
+    return null;
+  }
+  let index = start;
+  while (index < line.length && line[index] === marker) {
+    index += 1;
+  }
+  const markerCount = index - start;
+  if (markerCount === 0) {
+    return null;
+  }
+  for (; index < line.length; index += 1) {
+    const char = line[index];
+    if (char !== " " && char !== "	") {
+      return null;
+    }
+  }
+  return marker === "=" ? 1 : 2;
+}
+function parseTableAt(input, position, preferListToThematicBreak) {
+  const headerLine = readLine2(input, position);
+  if (parseListMarker(headerLine.text) !== null || stripBlockquoteMarker(headerLine.text) !== null) {
+    return null;
+  }
+  if (headerLine.nextPosition >= input.length) {
+    return null;
+  }
+  const separatorLine = readLine2(input, headerLine.nextPosition);
+  const header = parseTableHeaderAndSeparator(headerLine.text, separatorLine.text);
+  if (header === null) {
+    return null;
+  }
+  const rows = [];
+  let nextPosition = separatorLine.nextPosition;
+  while (nextPosition < input.length) {
+    const rowLine = readLine2(input, nextPosition);
+    if (isBlankLine(rowLine.text)) {
+      break;
+    }
+    if (startsSimpleBlock(rowLine.text, preferListToThematicBreak)) {
+      break;
+    }
+    const cells = parsePipeTableCells(rowLine.text);
+    if (cells === null) {
+      break;
+    }
+    rows.push(normalizeTableCells(cells, header.headerCells.length));
+    nextPosition = rowLine.nextPosition;
+  }
+  return {
+    align: header.align,
+    headerCells: header.headerCells,
+    rows,
+    nextPosition
+  };
+}
+function parseTableHeaderAndSeparator(headerLine, separatorLine) {
+  const headerCells = parsePipeTableCells(headerLine);
+  if (headerCells === null || headerCells.length === 0) {
+    return null;
+  }
+  const align = parsePipeTableSeparator(separatorLine);
+  if (align === null || align.length !== headerCells.length) {
+    return null;
+  }
+  return { align, headerCells };
+}
+function parsePipeTableCells(line) {
+  const start = skipLeadingBlockIndent(line);
+  if (start === -1 || start >= line.length) {
+    return null;
+  }
+  const content = trimAsciiWhitespaceEnd2(line.slice(start));
+  let hasPipe = false;
+  const cells = [];
+  let cell = "";
+  let index = 0;
+  while (index < content.length) {
+    const char = content[index];
+    if (char === "\\" && index + 1 < content.length && content[index + 1] === "|") {
+      cell += "|";
+      index += 2;
+      continue;
+    }
+    if (char === "|") {
+      cells.push(trimAsciiWhitespace3(cell));
+      cell = "";
+      hasPipe = true;
+      index += 1;
+      continue;
+    }
+    cell += char;
+    index += 1;
+  }
+  if (!hasPipe) {
+    return null;
+  }
+  cells.push(trimAsciiWhitespace3(cell));
+  if (content[0] === "|") {
+    cells.shift();
+  }
+  if (content[content.length - 1] === "|") {
+    cells.pop();
+  }
+  return cells.length === 0 ? null : cells;
+}
+function parsePipeTableSeparator(line) {
+  const cells = parsePipeTableCells(line);
+  if (cells === null || cells.length === 0) {
+    return null;
+  }
+  const alignments = [];
+  for (const cell of cells) {
+    const alignment = parseTableAlignmentCell(cell);
+    if (alignment === void 0) {
+      return null;
+    }
+    alignments.push(alignment);
+  }
+  return alignments;
+}
+function parseTableAlignmentCell(value) {
+  if (value.length === 0) {
+    return void 0;
+  }
+  const hasLeadingColon = value[0] === ":";
+  const hasTrailingColon = value[value.length - 1] === ":";
+  const dashStart = hasLeadingColon ? 1 : 0;
+  const dashEnd = hasTrailingColon ? value.length - 1 : value.length;
+  if (dashEnd - dashStart < 3) {
+    return void 0;
+  }
+  for (let index = dashStart; index < dashEnd; index += 1) {
+    if (value[index] !== "-") {
+      return void 0;
+    }
+  }
+  if (hasLeadingColon && hasTrailingColon) {
+    return "center";
+  }
+  if (hasLeadingColon) {
+    return "left";
+  }
+  if (hasTrailingColon) {
+    return "right";
+  }
+  return null;
+}
+function normalizeTableCells(cells, columnCount) {
+  if (cells.length === columnCount) {
+    return cells;
+  }
+  if (cells.length > columnCount) {
+    return cells.slice(0, columnCount);
+  }
+  return [...cells, ...Array.from({ length: columnCount - cells.length }, () => "")];
+}
+function stripBlockquoteMarker(line) {
+  const markerStart = skipLeadingBlockIndent(line);
+  if (markerStart === -1 || markerStart >= line.length || line[markerStart] !== ">") {
+    return null;
+  }
+  let contentStart = markerStart + 1;
+  if (contentStart < line.length && (line[contentStart] === " " || line[contentStart] === "	")) {
+    contentStart += 1;
+  }
+  return line.slice(contentStart);
+}
+function parseAlertMarker(content) {
+  const endOfKind = content.indexOf("]");
+  if (content.length === 0 || !content.startsWith("[!") || endOfKind === -1) {
+    return null;
+  }
+  const kind = content.slice(2, endOfKind);
+  if (!isAlertKind(kind)) {
+    return null;
+  }
+  return {
+    kind,
+    content: trimAsciiWhitespaceStart2(content.slice(endOfKind + 1))
+  };
+}
+function parseFootnoteDefinitionMarker(line) {
+  const markerStart = skipLeadingBlockIndent(line);
+  if (markerStart === -1 || markerStart + 3 >= line.length || line[markerStart] !== "[" || line[markerStart + 1] !== "^") {
+    return null;
+  }
+  let labelEnd = markerStart + 2;
+  while (labelEnd < line.length && line[labelEnd] !== "]") {
+    if (!isFootnoteLabelChar2(line[labelEnd])) {
+      return null;
+    }
+    labelEnd += 1;
+  }
+  if (labelEnd === markerStart + 2 || labelEnd + 1 >= line.length || line[labelEnd + 1] !== ":") {
+    return null;
+  }
+  let contentStart = labelEnd + 2;
+  while (contentStart < line.length && (line[contentStart] === " " || line[contentStart] === "	")) {
+    contentStart += 1;
+  }
+  return {
+    label: line.slice(markerStart + 2, labelEnd),
+    contentStart
+  };
+}
+function parseBlockHtmlTagStart(line) {
+  const start = skipLeadingBlockIndent(line);
+  if (start === -1 || start >= line.length || line[start] !== "<") {
+    return null;
+  }
+  let index = start + 1;
+  let closing = false;
+  if (index < line.length && line[index] === "/") {
+    closing = true;
+    index += 1;
+  }
+  if (index >= line.length || !isAsciiLetter2(line[index])) {
+    return null;
+  }
+  const tagNameStart = index;
+  while (index < line.length && isHtmlTagNameChar2(line[index])) {
+    index += 1;
+  }
+  const tagName = line.slice(tagNameStart, index).toLowerCase();
+  if (!BLOCK_HTML_TAGS.has(tagName)) {
+    return null;
+  }
+  if (closing) {
+    index = skipHtmlWhitespace2(line, index);
+    if (index >= line.length || line[index] !== ">") {
+      return null;
+    }
+    return {
+      tagName,
+      tagEnd: index + 1,
+      closing: true,
+      selfClosing: false
+    };
+  }
+  while (index < line.length) {
+    index = skipHtmlWhitespace2(line, index);
+    if (index >= line.length) {
+      return null;
+    }
+    if (line[index] === ">") {
+      return {
+        tagName,
+        tagEnd: index + 1,
+        closing: false,
+        selfClosing: false
+      };
+    }
+    if (line[index] === "/") {
+      const selfClosingStart = skipHtmlWhitespace2(line, index + 1);
+      if (selfClosingStart >= line.length || line[selfClosingStart] !== ">") {
+        return null;
+      }
+      return {
+        tagName,
+        tagEnd: selfClosingStart + 1,
+        closing: false,
+        selfClosing: true
+      };
+    }
+    if (!isHtmlAttributeNameStartChar2(line[index])) {
+      return null;
+    }
+    index += 1;
+    while (index < line.length && isHtmlAttributeNameChar2(line[index])) {
+      index += 1;
+    }
+    index = skipHtmlWhitespace2(line, index);
+    if (index >= line.length || line[index] !== "=") {
+      continue;
+    }
+    index = skipHtmlWhitespace2(line, index + 1);
+    if (index >= line.length) {
+      return null;
+    }
+    const quote = line[index];
+    if (quote === '"' || quote === "'") {
+      index += 1;
+      while (index < line.length && line[index] !== quote) {
+        index += 1;
+      }
+      if (index >= line.length) {
+        return null;
+      }
+      index += 1;
+      continue;
+    }
+    while (index < line.length && !isHtmlWhitespace2(line[index]) && line[index] !== ">") {
+      const char = line[index];
+      if (char === '"' || char === "'" || char === "<" || char === "=" || char === "`") {
+        return null;
+      }
+      index += 1;
+    }
+  }
+  return null;
+}
+function containsClosingHtmlTag(line, tagName, fromIndex = 0) {
+  const lowerLine = line.toLowerCase();
+  const needle = `</${tagName}`;
+  let searchIndex = fromIndex;
+  while (searchIndex < lowerLine.length) {
+    const matchIndex = lowerLine.indexOf(needle, searchIndex);
+    if (matchIndex === -1) {
+      return false;
+    }
+    let endIndex = matchIndex + needle.length;
+    while (endIndex < lowerLine.length && isHtmlWhitespace2(lowerLine[endIndex])) {
+      endIndex += 1;
+    }
+    if (endIndex < lowerLine.length && lowerLine[endIndex] === ">") {
+      return true;
+    }
+    searchIndex = matchIndex + 1;
+  }
+  return false;
+}
+function parseListMarker(line) {
+  const markerStart = skipLeadingBlockIndent(line);
+  if (markerStart === -1 || markerStart >= line.length) {
+    return null;
+  }
+  const marker = line[markerStart];
+  if (marker === "-" || marker === "+" || marker === "*") {
+    return parseBulletListMarker(line, markerStart);
+  }
+  if (isDigit2(marker)) {
+    return parseOrderedListMarker(line, markerStart);
+  }
+  return null;
+}
+function parseBulletListMarker(line, markerStart) {
+  const contentStart = parseContentStart(line, markerStart + 1);
+  if (contentStart === null) {
+    return null;
+  }
+  return {
+    ordered: false,
+    indent: measureColumns(line.slice(0, markerStart)),
+    contentIndent: measureColumns(line.slice(0, contentStart)),
+    contentStart
+  };
+}
+function parseOrderedListMarker(line, markerStart) {
+  let markerEnd = markerStart;
+  while (markerEnd < line.length && isDigit2(line[markerEnd])) {
+    markerEnd += 1;
+  }
+  if (markerEnd >= line.length || line[markerEnd] !== "." && line[markerEnd] !== ")") {
+    return null;
+  }
+  const contentStart = parseContentStart(line, markerEnd + 1);
+  if (contentStart === null) {
+    return null;
+  }
+  return {
+    ordered: true,
+    start: Number.parseInt(line.slice(markerStart, markerEnd), 10),
+    indent: measureColumns(line.slice(0, markerStart)),
+    contentIndent: measureColumns(line.slice(0, contentStart)),
+    contentStart
+  };
+}
+function parseContentStart(line, afterMarker) {
+  if (afterMarker >= line.length) {
+    return afterMarker;
+  }
+  if (line[afterMarker] !== " " && line[afterMarker] !== "	") {
+    return null;
+  }
+  let pos = afterMarker;
+  while (pos < line.length && (line[pos] === " " || line[pos] === "	")) {
+    pos += 1;
+  }
+  return pos;
+}
+function readLine2(input, position) {
+  let index = position;
+  while (index < input.length) {
+    const char = input[index];
+    if (char === "\n" || char === "\r") {
+      break;
+    }
+    index += 1;
+  }
+  const text4 = input.slice(position, index);
+  if (index >= input.length) {
+    return { text: text4, nextPosition: input.length };
+  }
+  if (input[index] === "\r" && input[index + 1] === "\n") {
+    return { text: text4, nextPosition: index + 2 };
+  }
+  return { text: text4, nextPosition: index + 1 };
+}
+function isBlankLine(line) {
+  for (let index = 0; index < line.length; index += 1) {
+    const char = line[index];
+    if (char !== " " && char !== "	") {
+      return false;
+    }
+  }
+  return true;
+}
+function skipLeadingBlockIndent(line) {
+  const leadingWhitespace = readLeadingWhitespace(line);
+  if (leadingWhitespace.columns > 3) {
+    return -1;
+  }
+  return leadingWhitespace.offset;
+}
+function trimAsciiWhitespace3(value) {
+  return trimAsciiWhitespaceEnd2(trimAsciiWhitespaceStart2(value));
+}
+function trimAsciiWhitespaceStart2(value) {
+  let start = 0;
+  while (start < value.length) {
+    const char = value[start];
+    if (char !== " " && char !== "	") {
+      break;
+    }
+    start += 1;
+  }
+  return value.slice(start);
+}
+function trimAsciiWhitespaceEnd2(value) {
+  let end = value.length;
+  while (end > 0) {
+    const char = value[end - 1];
+    if (char !== " " && char !== "	") {
+      break;
+    }
+    end -= 1;
+  }
+  return value.slice(0, end);
+}
+function findWhitespaceIndex(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index];
+    if (char === " " || char === "	") {
+      return index;
+    }
+  }
+  return -1;
+}
+function skipHtmlWhitespace2(line, start) {
+  let index = start;
+  while (index < line.length && isHtmlWhitespace2(line[index])) {
+    index += 1;
+  }
+  return index;
+}
+function isDigit2(value) {
+  return value >= "0" && value <= "9";
+}
+function isAsciiLetter2(value) {
+  return value >= "a" && value <= "z" || value >= "A" && value <= "Z";
+}
+function isHtmlTagNameChar2(value) {
+  return isAsciiLetter2(value) || isDigit2(value) || value === "-";
+}
+function isHtmlAttributeNameStartChar2(value) {
+  return isAsciiLetter2(value) || value === ":" || value === "_";
+}
+function isHtmlAttributeNameChar2(value) {
+  return isHtmlAttributeNameStartChar2(value) || isDigit2(value) || value === "-" || value === ".";
+}
+function isHtmlWhitespace2(value) {
+  return value === " " || value === "	";
+}
+function isFootnoteLabelChar2(value) {
+  return isAsciiLetter2(value) || isDigit2(value) || value === "-" || value === "_";
+}
+function isAlertKind(value) {
+  return value === "NOTE" || value === "TIP" || value === "IMPORTANT" || value === "WARNING" || value === "CAUTION";
+}
+function stripBom2(input) {
+  return input[0] === "\uFEFF" ? input.slice(1) : input;
+}
+function parseListItem(state, list) {
+  const firstLine = readLine2(state.input, state.position);
+  const marker = parseListMarker(firstLine.text);
+  if (marker === null || marker.ordered !== list.ordered || marker.indent !== list.indent) {
+    return null;
+  }
+  state.position = firstLine.nextPosition;
+  let firstLineContent = firstLine.text.slice(marker.contentStart);
+  let checked;
+  const taskMarker = parseTaskMarker(firstLineContent);
+  if (taskMarker !== null) {
+    checked = taskMarker.checked;
+    firstLineContent = taskMarker.content;
+  }
+  const continuationLines = [];
+  const pendingBlankLines = [];
+  while (state.position < state.input.length) {
+    const line = readLine2(state.input, state.position);
+    if (isBlankLine(line.text)) {
+      pendingBlankLines.push("");
+      state.position = line.nextPosition;
+      continue;
+    }
+    const nextMarker = parseListMarker(line.text);
+    if (nextMarker !== null && nextMarker.ordered === list.ordered && nextMarker.indent === list.indent) {
+      break;
+    }
+    const strippedLine = stripIndent(line.text, marker.contentIndent);
+    if (strippedLine === null) {
+      break;
+    }
+    state.position = line.nextPosition;
+    continuationLines.push(...pendingBlankLines, strippedLine);
+    pendingBlankLines.length = 0;
+  }
+  const children = parseListItemChildren(
+    firstLineContent,
+    continuationLines,
+    list.preferListToThematicBreak
+  );
+  return {
+    type: "listItem",
+    ...checked === void 0 ? {} : { checked },
+    children
+  };
+}
+function parseListItemChildren(firstLineContent, continuationLines, preferListToThematicBreak) {
+  const blocks = [];
+  let paragraphLines = firstLineContent.length === 0 ? [] : [firstLineContent];
+  let lineIndex = 0;
+  while (lineIndex < continuationLines.length) {
+    const line = continuationLines[lineIndex];
+    if (isBlankLine(line)) {
+      if (paragraphLines.length > 0) {
+        blocks.push(createParagraphNode(paragraphLines));
+        paragraphLines = [];
+      }
+      lineIndex += 1;
+      continue;
+    }
+    if (startsBlockInLines(continuationLines, lineIndex, preferListToThematicBreak)) {
+      if (paragraphLines.length > 0) {
+        blocks.push(createParagraphNode(paragraphLines));
+      }
+      blocks.push(
+        ...parseBlocksWithOptions(continuationLines.slice(lineIndex).join("\n"), {
+          preferListToThematicBreak
+        })
+      );
+      return blocks;
+    }
+    paragraphLines.push(line);
+    lineIndex += 1;
+  }
+  if (paragraphLines.length > 0) {
+    blocks.push(createParagraphNode(paragraphLines));
+  }
+  return blocks;
+}
+function createParagraphNode(lines) {
+  return {
+    type: "paragraph",
+    children: [{ type: "text", value: lines.join("\n") }]
+  };
+}
+function parseTaskMarker(content) {
+  if (content.length < 3 || content[0] !== "[" || content[2] !== "]") {
+    return null;
+  }
+  const marker = content[1];
+  if (marker !== " " && marker !== "x" && marker !== "X") {
+    return null;
+  }
+  if (content.length > 3 && content[3] !== " " && content[3] !== "	") {
+    return null;
+  }
+  return {
+    checked: marker === "x" || marker === "X",
+    content: trimAsciiWhitespaceStart2(content.slice(3))
+  };
+}
+function stripIndent(line, columns) {
+  const leadingWhitespace = readLeadingWhitespace(line);
+  if (leadingWhitespace.columns < columns) {
+    return null;
+  }
+  return leadingWhitespace.normalized.slice(columns) + line.slice(leadingWhitespace.offset);
+}
+function readLeadingWhitespace(line) {
+  let columns = 0;
+  let offset = 0;
+  let normalized = "";
+  while (offset < line.length) {
+    const char = line[offset];
+    if (char === " ") {
+      columns += 1;
+      normalized += " ";
+      offset += 1;
+      continue;
+    }
+    if (char === "	") {
+      columns += 4;
+      normalized += "    ";
+      offset += 1;
+      continue;
+    }
+    break;
+  }
+  return { columns, offset, normalized };
+}
+function measureColumns(value) {
+  let columns = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    columns += value[index] === "	" ? 4 : 1;
+  }
+  return columns;
+}
+var BLOCK_HTML_TAGS, VOID_BLOCK_HTML_TAGS;
+var init_block = __esm({
+  "packages/design-system/src/terminal-markdown/parser/block.ts"() {
+    "use strict";
+    init_frontmatter();
+    init_inline();
+    BLOCK_HTML_TAGS = /* @__PURE__ */ new Set([
+      "address",
+      "article",
+      "aside",
+      "base",
+      "basefont",
+      "blockquote",
+      "body",
+      "caption",
+      "center",
+      "col",
+      "colgroup",
+      "dd",
+      "details",
+      "dialog",
+      "dir",
+      "div",
+      "dl",
+      "dt",
+      "fieldset",
+      "figcaption",
+      "figure",
+      "footer",
+      "form",
+      "frame",
+      "frameset",
+      "h1",
+      "h2",
+      "h3",
+      "h4",
+      "h5",
+      "h6",
+      "head",
+      "header",
+      "hr",
+      "html",
+      "iframe",
+      "legend",
+      "li",
+      "link",
+      "main",
+      "menu",
+      "menuitem",
+      "nav",
+      "noframes",
+      "ol",
+      "optgroup",
+      "option",
+      "p",
+      "param",
+      "search",
+      "section",
+      "summary",
+      "table",
+      "tbody",
+      "td",
+      "tfoot",
+      "th",
+      "thead",
+      "title",
+      "tr",
+      "track",
+      "ul"
+    ]);
+    VOID_BLOCK_HTML_TAGS = /* @__PURE__ */ new Set(["base", "basefont", "col", "hr", "link", "param", "track"]);
+  }
+});
+
+// packages/design-system/src/terminal-markdown/parser.ts
+function parse4(markdown) {
+  const { frontmatter, children } = parseBlockDocument(markdown);
+  return {
+    ...frontmatter === void 0 ? {} : { frontmatter },
+    ast: {
+      type: "root",
+      children: frontmatter === void 0 ? children : [{ type: "frontmatter", data: frontmatter }, ...children]
+    }
+  };
+}
+var init_parser = __esm({
+  "packages/design-system/src/terminal-markdown/parser.ts"() {
+    "use strict";
+    init_block();
+  }
+});
+
+// packages/design-system/src/terminal-markdown/renderer.ts
+function render(ast, options = {}) {
+  const width = Math.max(1, options.width ?? process.stdout.columns ?? widths.maxLine);
+  const context = {
+    width,
+    showFrontmatter: options.showFrontmatter ?? false,
+    theme: getTheme(),
+    footnotes: ast.type === "root" ? createFootnoteState(ast.children) : void 0
+  };
+  return renderNode(ast, context);
+}
+function renderNode(node, context) {
+  switch (node.type) {
+    case "root":
+      return renderRoot(node, context);
+    case "heading":
+      return renderHeading(node, context);
+    case "paragraph":
+      return renderParagraph(node, context);
+    case "blockquote":
+      return renderBlockquote(node, context);
+    case "alert":
+      return renderAlert(node, context);
+    case "code":
+      return renderCodeBlock(node, context);
+    case "list":
+      return renderList(node, context);
+    case "table":
+      return renderTable2(node, context);
+    case "html":
+      return renderHtml(node, context);
+    case "text":
+    case "strong":
+    case "emphasis":
+    case "strikethrough":
+    case "inlineCode":
+    case "link":
+    case "image":
+    case "break":
+    case "footnoteReference":
+      return renderInline([node], context).join("\n");
+    case "thematicBreak":
+      return `${context.theme.divider(lineChar.repeat(context.width))}
+
+`;
+    case "frontmatter":
+      return context.showFrontmatter ? renderFrontmatter(node.data, context) : "";
+    case "footnoteDefinition":
+      return "";
+    default:
+      return "children" in node ? renderChildren(node.children, context) : "";
+  }
+}
+function renderRoot(node, context) {
+  const mainOutput = renderChildren(
+    node.children.filter((child) => child.type !== "footnoteDefinition"),
+    context
+  );
+  const footnotesOutput = renderReferencedFootnotes(context);
+  return `${mainOutput}${footnotesOutput}`;
+}
+function renderChildren(children, context) {
+  return children.map((child) => renderNode(child, context)).join("");
+}
+function renderParagraph(node, context) {
+  const lines = renderInline(node.children, context);
+  if (lines.length === 0) {
+    return "";
+  }
+  return `${lines.join("\n")}
+
+`;
+}
+function renderHeading(node, context) {
+  const lines = renderInline(node.children, context);
+  if (lines.length === 0) {
+    return "";
+  }
+  const styledLines = lines.map((line) => styleHeading(line, node.depth, context));
+  if (node.depth === 1) {
+    const underlineWidth = Math.max(...lines.map((line) => stripAnsi2(line).length));
+    return `${styledLines.join("\n")}
+${context.theme.header(lineChar.repeat(underlineWidth))}
+
+`;
+  }
+  return `${styledLines.join("\n")}
+
+`;
+}
+function renderBlockquote(node, context) {
+  const prefix = `${symbols.bar} `;
+  const body = renderBlockChildren(node.children, reduceWidth(context, prefix));
+  if (body.length === 0) {
+    return `${symbols.bar}
+
+`;
+  }
+  const lines = body.split("\n").map((line) => line.length > 0 ? `${prefix}${typography.dim(line)}` : symbols.bar);
+  return `${lines.join("\n")}
+
+`;
+}
+function renderAlert(node, context) {
+  const prefix = `${symbols.bar} `;
+  const labelLine = `${prefix}${formatAlertLabel(node.kind, context)}`;
+  const body = renderBlockChildren(node.children, reduceWidth(context, prefix));
+  if (body.length === 0) {
+    return `${labelLine}
+
+`;
+  }
+  const lines = body.split("\n").map((line) => line.length > 0 ? `${prefix}${line}` : symbols.bar);
+  return `${labelLine}
+${lines.join("\n")}
+
+`;
+}
+function renderCodeBlock(node, context) {
+  const indent = " ".repeat(spacing.sm);
+  const lines = node.value.split("\n");
+  const longestLine = lines.reduce((max, line) => Math.max(max, line.length), 0);
+  const borderWidth = Math.max(3, Math.min(context.width - indent.length, longestLine));
+  const border = context.theme.muted(`${indent}${lineChar.repeat(borderWidth)}`);
+  const content = lines.map((line) => `${indent}${line}`).join("\n");
+  return `${border}
+${content}
+${border}
+
+`;
+}
+function renderList(node, context) {
+  const items = node.children.map((child, index) => {
+    if (child.type !== "listItem") {
+      return renderNode(child, context).trimEnd();
+    }
+    return renderListItem(child, node, index, context);
+  }).filter((item) => item.length > 0);
+  if (items.length === 0) {
+    return "";
+  }
+  return `${items.join("\n")}
+
+`;
+}
+function renderTable2(node, context) {
+  const rows = node.children.filter((child) => child.type === "tableRow");
+  if (rows.length === 0) {
+    return "";
+  }
+  const columnCount = Math.max(node.align.length, ...rows.map((row) => row.children.length));
+  if (columnCount === 0) {
+    return "";
+  }
+  const renderedRows = rows.map(
+    (row) => Array.from({ length: columnCount }, (_2, columnIndex) => {
+      const cell = row.children[columnIndex];
+      return cell?.type === "tableCell" ? renderTableCell(cell, context) : "";
+    })
+  );
+  const columnWidths = Array.from(
+    { length: columnCount },
+    (_2, columnIndex) => Math.max(...renderedRows.map((row) => stripAnsi2(row[columnIndex] ?? "").length), 0)
+  );
+  if (getRenderedTableWidth(columnWidths) > context.width) {
+    return renderStackedTable(rows, columnCount, context);
+  }
+  const lines = renderedRows.map(
+    (row, rowIndex) => row.map(
+      (cell, columnIndex) => alignTableCell(
+        rowIndex === 0 ? context.theme.header(typography.bold(cell)) : cell,
+        columnWidths[columnIndex] ?? 0,
+        node.align[columnIndex] ?? null
+      )
+    )
+  );
+  const outputLines = lines.map((row, rowIndex) => {
+    const line = `${symbols.bar}${row.map((cell) => `${" ".repeat(spacing.sm)}${cell}${" ".repeat(spacing.sm)}`).join(symbols.bar)}${symbols.bar}`;
+    if (rowIndex !== 0 || lines.length === 1) {
+      return line;
+    }
+    const divider = context.theme.muted(
+      `\u251C${columnWidths.map((width) => lineChar.repeat(width + spacing.sm * 2)).join("\u253C")}\u2524`
+    );
+    return `${line}
+${divider}`;
+  });
+  return `${outputLines.join("\n")}
+
+`;
+}
+function renderStackedTable(rows, columnCount, context) {
+  const headerRow = rows[0];
+  if (headerRow === void 0) {
+    return "";
+  }
+  const dataRows = rows.slice(1);
+  if (dataRows.length === 0) {
+    const headerLines = Array.from(
+      { length: columnCount },
+      (_2, columnIndex) => tokenizeText(getStackedTableLabel(headerRow.children[columnIndex], columnIndex, context), [typography.bold])
+    ).flatMap((tokens) => wrapTokens(tokens, context.width));
+    return headerLines.length === 0 ? "" : `${headerLines.join("\n")}
+
+`;
+  }
+  const blocks = dataRows.map(
+    (row) => Array.from(
+      { length: columnCount },
+      (_2, columnIndex) => renderStackedTableField(headerRow.children[columnIndex], row.children[columnIndex], columnIndex, context)
+    ).filter((field) => field.length > 0).join("\n")
+  ).filter((block) => block.length > 0);
+  return blocks.length === 0 ? "" : `${blocks.join("\n\n")}
+
+`;
+}
+function renderListItem(node, list, index, context) {
+  const marker = getListMarker(node, list, index);
+  const indent = " ".repeat(spacing.sm);
+  const firstPrefix = `${indent}${marker} `;
+  const body = renderBlockChildren(node.children, reduceWidth(context, firstPrefix));
+  const continuationPrefix = `${indent}${" ".repeat(marker.length + 1)}`;
+  if (body.length === 0) {
+    return firstPrefix.trimEnd();
+  }
+  return prefixBlock(body, firstPrefix, continuationPrefix);
+}
+function styleHeading(value, depth, context) {
+  if (depth <= 2) {
+    return context.theme.header(typography.bold(value));
+  }
+  if (depth <= 4) {
+    return typography.bold(value);
+  }
+  return context.theme.muted(typography.bold(value));
+}
+function renderFrontmatter(data, context) {
+  const entries = Object.entries(data);
+  if (entries.length === 0) {
+    return "";
+  }
+  const lines = entries.flatMap(
+    ([key, value]) => wrapText(`${key}: ${formatFrontmatterValue(value)}`, context.width).map(
+      (line) => typography.dim(line)
+    )
+  );
+  return `${lines.join("\n")}
+
+`;
+}
+function formatFrontmatterValue(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return JSON.stringify(value);
+}
+function renderHtml(node, context) {
+  const value = stripHtmlTags(node.value).trim();
+  if (value.length === 0) {
+    return "";
+  }
+  const lines = wrapText(value, context.width);
+  if (lines.length === 0) {
+    return "";
+  }
+  return `${lines.join("\n")}
+
+`;
+}
+function renderBlockChildren(children, context) {
+  const renderedChildren = children.map((child) => ({
+    type: child.type,
+    value: renderNode(child, context).trimEnd()
+  })).filter((child) => child.value.length > 0);
+  if (renderedChildren.length === 0) {
+    return "";
+  }
+  let output = renderedChildren[0].value;
+  for (let index = 1; index < renderedChildren.length; index += 1) {
+    const previous = renderedChildren[index - 1];
+    const current = renderedChildren[index];
+    const separator = previous.type === "paragraph" && current.type === "list" ? "\n" : "\n\n";
+    output += `${separator}${current.value}`;
+  }
+  return output;
+}
+function renderReferencedFootnotes(context) {
+  const footnotes = context.footnotes;
+  if (footnotes === void 0 || footnotes.labelsInOrder.length === 0) {
+    return "";
+  }
+  const rendered = [];
+  for (let index = 0; index < footnotes.labelsInOrder.length; index += 1) {
+    const label = footnotes.labelsInOrder[index];
+    const definition = footnotes.definitions.get(label);
+    const number = footnotes.numbers.get(label);
+    if (definition !== void 0 && number !== void 0) {
+      rendered.push(renderFootnoteDefinition(definition, number, context));
+    }
+  }
+  if (rendered.length === 0) {
+    return "";
+  }
+  return `${rendered.join("\n")}
+
+`;
+}
+function renderFootnoteDefinition(node, number, context) {
+  const marker = typography.dim(`[${number}]`);
+  const firstPrefix = `${" ".repeat(spacing.sm)}${marker} `;
+  const continuationPrefix = `${" ".repeat(spacing.sm + stripAnsi2(`[${number}] `).length)}`;
+  const body = renderBlockChildren(node.children, reduceWidth(context, firstPrefix));
+  if (body.length === 0) {
+    return firstPrefix.trimEnd();
+  }
+  return prefixBlock(body, firstPrefix, continuationPrefix);
+}
+function getListMarker(node, list, index) {
+  if (node.checked === true) {
+    return symbols.active;
+  }
+  if (node.checked === false) {
+    return symbols.inactive;
+  }
+  if (list.ordered) {
+    return `${(list.start ?? 1) + index}.`;
+  }
+  return "\u2022";
+}
+function prefixBlock(rendered, firstPrefix, restPrefix) {
+  return rendered.split("\n").map((line, index) => {
+    const prefix = index === 0 ? firstPrefix : restPrefix;
+    return line.length > 0 ? `${prefix}${line}` : prefix.trimEnd();
+  }).join("\n");
+}
+function reduceWidth(context, prefix) {
+  return {
+    ...context,
+    width: Math.max(1, context.width - stripAnsi2(prefix).length)
+  };
+}
+function renderInline(nodes, context) {
+  const tokens = tokenizeInline(nodes, context);
+  return wrapTokens(tokens, context.width);
+}
+function tokenizeInline(nodes, context) {
+  const tokens = [];
+  for (const node of nodes) {
+    collectInlineTokens(node, [], context, tokens);
+  }
+  return tokens;
+}
+function collectInlineTokens(node, formatters, context, tokens) {
+  switch (node.type) {
+    case "text":
+      tokens.push(...tokenizeText(node.value, formatters));
+      return;
+    case "strong":
+      collectChildren(node.children, [...formatters, typography.bold], context, tokens);
+      return;
+    case "emphasis":
+      collectChildren(node.children, [...formatters, typography.italic], context, tokens);
+      return;
+    case "strikethrough":
+      collectChildren(node.children, [...formatters, typography.strikethrough], context, tokens);
+      return;
+    case "inlineCode":
+      tokens.push(...tokenizeText(node.value, [...formatters, context.theme.accent]));
+      return;
+    case "link":
+      collectLinkTokens(node, formatters, context, tokens);
+      return;
+    case "image":
+      tokens.push(createWordToken(formatImagePlaceholder(node.alt), [...formatters, context.theme.muted]));
+      return;
+    case "footnoteReference": {
+      const footnoteNumber = resolveFootnoteNumber(node.label, context);
+      if (footnoteNumber !== null) {
+        tokens.push(createWordToken(`[${footnoteNumber}]`, [...formatters, typography.dim]));
+      }
+      return;
+    }
+    case "html": {
+      const value = stripHtmlTags(node.value);
+      if (value.length > 0) {
+        tokens.push(...tokenizeText(value, formatters));
+      }
+      return;
+    }
+    case "break":
+      tokens.push({ type: "break" });
+      return;
+    default:
+      if ("children" in node) {
+        collectChildren(node.children, formatters, context, tokens);
+      }
+  }
+}
+function collectChildren(children, formatters, context, tokens) {
+  for (const child of children) {
+    collectInlineTokens(child, formatters, context, tokens);
+  }
+}
+function collectLinkTokens(node, formatters, context, tokens) {
+  if (isAutolink(node)) {
+    tokens.push(createWordToken(node.url, [...formatters, context.theme.accent]));
+    return;
+  }
+  const childTokens = [];
+  collectChildren(node.children, formatters, context, childTokens);
+  const trimmedChildTokens = trimTrailingSpaces(childTokens);
+  tokens.push(...trimmedChildTokens);
+  if (trimmedChildTokens.some((token) => token.type === "word")) {
+    tokens.push({ type: "space", value: " " });
+  }
+  tokens.push(createWordToken(`(${node.url})`, [...formatters, context.theme.accent]));
+}
+function isAutolink(node) {
+  if (node.children.length !== 1 || node.children[0]?.type !== "text") {
+    return false;
+  }
+  const label = node.children[0].value;
+  return label === node.url || node.url.startsWith("http://") && label === node.url.slice("http://".length) || node.url.startsWith("mailto:") && label === node.url.slice("mailto:".length);
+}
+function formatImagePlaceholder(alt) {
+  return alt.length > 0 ? `[image: ${alt}]` : "[image]";
+}
+function createWordToken(value, formatters) {
+  return { type: "word", value, formatters };
+}
+function trimTrailingSpaces(tokens) {
+  let end = tokens.length;
+  while (end > 0 && tokens[end - 1]?.type === "space") {
+    end -= 1;
+  }
+  return tokens.slice(0, end);
+}
+function tokenizeText(value, formatters) {
+  const lines = value.split("\n");
+  return lines.flatMap((line, lineIndex) => {
+    const pieces = line.split(/([ \t]+)/).filter((piece) => piece.length > 0).map(
+      (piece) => /^[ \t]+$/.test(piece) ? { type: "space", value: piece } : { type: "word", value: piece, formatters }
+    );
+    return lineIndex < lines.length - 1 ? [...pieces, { type: "break" }] : pieces;
+  });
+}
+function wrapTokens(tokens, width) {
+  const lines = [];
+  let currentLine = "";
+  let currentWidth = 0;
+  let pendingSpace = "";
+  const flushLine = () => {
+    lines.push(currentLine);
+    currentLine = "";
+    currentWidth = 0;
+    pendingSpace = "";
+  };
+  for (const token of tokens) {
+    if (token.type === "break") {
+      flushLine();
+      continue;
+    }
+    if (token.type === "space") {
+      if (currentWidth > 0) {
+        pendingSpace += token.value;
+      }
+      continue;
+    }
+    const chunks = splitWord(token.value, width);
+    for (let index = 0; index < chunks.length; index++) {
+      const chunk = chunks[index];
+      const gap = index === 0 ? pendingSpace : "";
+      const gapWidth = gap.length;
+      if (currentWidth > 0 && currentWidth + chunk.length + gapWidth > width) {
+        flushLine();
+      }
+      if (currentWidth > 0 && gapWidth > 0) {
+        currentLine += gap;
+        currentWidth += gapWidth;
+      }
+      currentLine += applyFormatters(chunk, token.formatters);
+      currentWidth += chunk.length;
+      pendingSpace = "";
+      if (index < chunks.length - 1) {
+        flushLine();
+      }
+    }
+  }
+  if (currentLine.length > 0) {
+    lines.push(currentLine);
+  }
+  return lines;
+}
+function splitWord(value, width) {
+  if (value.length <= width) {
+    return [value];
+  }
+  const chunks = [];
+  for (let index = 0; index < value.length; index += width) {
+    chunks.push(value.slice(index, index + width));
+  }
+  return chunks;
 }
-function formatOptionList(options) {
-  return options.map((opt) => formatOption(opt.flags, opt.description)).join("\n");
+function applyFormatters(value, formatters) {
+  return formatters.reduce((text4, formatter) => formatter(text4), value);
 }
-var init_help_formatter = __esm({
-  "packages/design-system/src/components/help-formatter.ts"() {
-    "use strict";
-    init_text();
-    init_widths();
-  }
-});
-
-// packages/design-system/src/components/command-errors.ts
-function formatCommandNotFound(input) {
-  const unknown = input.unknownCommand.length > 0 ? input.unknownCommand : "<command>";
-  return {
-    label: `${typography.bold("Unknown command:")} ${text.command(unknown)}`,
-    hint: `${text.muted("Run")} ${text.usageCommand(input.helpCommand)} ${text.muted("for available commands.")}`
-  };
+function wrapText(value, width) {
+  const tokens = tokenizeText(value, []);
+  return wrapTokens(tokens, Math.max(1, width));
 }
-function formatCommandNotFoundPanel(input) {
-  const message2 = formatCommandNotFound({
-    unknownCommand: input.unknownCommand,
-    helpCommand: input.helpCommand
-  });
+function createFootnoteState(children) {
   return {
-    title: input.title ?? "command not found",
-    label: message2.label,
-    footer: message2.hint
+    definitions: new Map(
+      children.flatMap(
+        (child) => child.type === "footnoteDefinition" ? [[child.label, child]] : []
+      )
+    ),
+    labelsInOrder: [],
+    numbers: /* @__PURE__ */ new Map()
   };
 }
-var init_command_errors = __esm({
-  "packages/design-system/src/components/command-errors.ts"() {
-    "use strict";
-    init_typography();
-    init_text();
+function resolveFootnoteNumber(label, context) {
+  const footnotes = context.footnotes;
+  if (footnotes === void 0 || !footnotes.definitions.has(label)) {
+    return null;
   }
-});
-
-// packages/design-system/src/components/table.ts
-import { Table } from "console-table-printer";
-function renderTableTerminal(options) {
-  const { theme, columns, rows } = options;
-  const table = new Table({
-    style: {
-      headerTop: {
-        left: theme.muted("\u250C"),
-        mid: theme.muted("\u252C"),
-        right: theme.muted("\u2510"),
-        other: theme.muted("\u2500")
-      },
-      headerBottom: {
-        left: theme.muted("\u251C"),
-        mid: theme.muted("\u253C"),
-        right: theme.muted("\u2524"),
-        other: theme.muted("\u2500")
-      },
-      tableBottom: {
-        left: theme.muted("\u2514"),
-        mid: theme.muted("\u2534"),
-        right: theme.muted("\u2518"),
-        other: theme.muted("\u2500")
-      },
-      vertical: theme.muted("\u2502"),
-      rowSeparator: {
-        left: theme.muted("\u251C"),
-        mid: theme.muted("\u253C"),
-        right: theme.muted("\u2524"),
-        other: theme.muted("\u2500")
-      }
-    },
-    columns: columns.map((col) => ({
-      name: col.name,
-      title: theme.header(col.title),
-      alignment: col.alignment,
-      maxLen: col.maxLen
-    }))
-  });
-  for (const row of rows) {
-    table.addRow(row);
+  const existing = footnotes.numbers.get(label);
+  if (existing !== void 0) {
+    return existing;
   }
-  return table.render();
+  const number = footnotes.numbers.size + 1;
+  footnotes.numbers.set(label, number);
+  footnotes.labelsInOrder.push(label);
+  return number;
 }
-function renderTableMarkdown(options) {
-  const { columns, rows } = options;
-  const header = `| ${columns.map((c2) => c2.title).join(" | ")} |`;
-  const separator = `| ${columns.map((c2) => c2.alignment === "right" ? "---:" : ":---").join(" | ")} |`;
-  const dataRows = rows.map(
-    (row) => `| ${columns.map((c2) => stripAnsi2(row[c2.name] ?? "").replace(/\|/g, "\\|")).join(" | ")} |`
+function formatAlertLabel(kind, context) {
+  switch (kind) {
+    case "NOTE":
+      return context.theme.info("Note");
+    case "TIP":
+      return context.theme.success("Tip");
+    case "IMPORTANT":
+      return context.theme.info("Important");
+    case "WARNING":
+      return context.theme.warning("Warning");
+    case "CAUTION":
+      return context.theme.error("Caution");
+  }
+}
+function renderTableCell(node, context) {
+  return wrapTokens(tokenizeInline(node.children, context), Number.MAX_SAFE_INTEGER).join(" ");
+}
+function renderStackedTableField(headerCell, cell, columnIndex, context) {
+  const tokens = [
+    ...tokenizeText(getStackedTableLabel(headerCell, columnIndex, context), [typography.bold]),
+    createWordToken(":", [typography.bold]),
+    { type: "space", value: " " },
+    ...getStackedTableValueTokens(cell, context)
+  ];
+  return wrapTokens(tokens, context.width).join("\n");
+}
+function getStackedTableLabel(headerCell, columnIndex, context) {
+  if (headerCell?.type !== "tableCell") {
+    return `Column ${columnIndex + 1}`;
+  }
+  const label = stripAnsi2(renderTableCell(headerCell, context)).trim();
+  return label.length > 0 ? label : `Column ${columnIndex + 1}`;
+}
+function getStackedTableValueTokens(cell, context) {
+  if (cell?.type !== "tableCell") {
+    return [createWordToken("\u2014", [context.theme.muted])];
+  }
+  const tokens = trimTrailingSpaces(tokenizeInline(cell.children, context));
+  return tokens.length > 0 ? tokens : [createWordToken("\u2014", [context.theme.muted])];
+}
+function getRenderedTableWidth(columnWidths) {
+  return columnWidths.reduce(
+    (totalWidth, width) => totalWidth + width + spacing.sm * 2,
+    columnWidths.length + 1
   );
-  return [header, separator, ...dataRows].join("\n");
 }
-function renderTableJson(options) {
-  const { columns, rows } = options;
-  const cleaned = rows.map((row) => {
-    const obj = {};
-    for (const col of columns) {
-      obj[col.name] = stripAnsi2(row[col.name] ?? "");
-    }
-    return obj;
-  });
-  return JSON.stringify(cleaned, null, 2);
+function alignTableCell(value, width, align) {
+  const visibleWidth = stripAnsi2(value).length;
+  const extraSpace = Math.max(0, width - visibleWidth);
+  if (align === "right") {
+    return `${" ".repeat(extraSpace)}${value}`;
+  }
+  if (align === "center") {
+    const leftPadding = Math.floor(extraSpace / 2);
+    const rightPadding = extraSpace - leftPadding;
+    return `${" ".repeat(leftPadding)}${value}${" ".repeat(rightPadding)}`;
+  }
+  return `${value}${" ".repeat(extraSpace)}`;
 }
-function renderTable(options) {
-  const format = resolveOutputFormat();
-  switch (format) {
-    case "markdown":
-      return renderTableMarkdown(options);
-    case "json":
-      return renderTableJson(options);
-    default:
-      return renderTableTerminal(options);
+function stripHtmlTags(value) {
+  let output = "";
+  let inTag = false;
+  for (const char of value) {
+    if (char === "<") {
+      inTag = true;
+      continue;
+    }
+    if (char === ">" && inTag) {
+      inTag = false;
+      continue;
+    }
+    if (!inTag) {
+      output += char;
+    }
   }
+  return output;
 }
-var init_table = __esm({
-  "packages/design-system/src/components/table.ts"() {
+var lineChar;
+var init_renderer = __esm({
+  "packages/design-system/src/terminal-markdown/renderer.ts"() {
     "use strict";
-    init_output_format();
+    init_symbols();
+    init_theme_detect();
     init_strip_ansi();
+    init_spacing();
+    init_typography();
+    init_widths();
+    lineChar = "\u2500";
+  }
+});
+
+// packages/design-system/src/terminal-markdown/index.ts
+function renderMarkdown(markdown, options) {
+  const { ast } = parse4(markdown);
+  return render(ast, options);
+}
+var init_terminal_markdown = __esm({
+  "packages/design-system/src/terminal-markdown/index.ts"() {
+    "use strict";
+    init_parser();
+    init_renderer();
+    init_parser();
+    init_renderer();
   }
 });
 
@@ -3991,10 +7295,11 @@ function renderAgentMessage(text4) {
     return;
   }
   if (format === "json") {
-    writeLine(JSON.stringify({ type: "agent", message: text4 }));
+    writeLine(JSON.stringify({ event: "agent_message", text: text4 }));
     return;
   }
-  writeLine(`${AGENT_PREFIX}${text4}`);
+  const rendered = renderMarkdown(text4).trimEnd();
+  writeLine(`${AGENT_PREFIX}${rendered}`);
 }
 function renderToolStart(kind, title) {
   const format = resolveOutputFormat();
@@ -4003,7 +7308,7 @@ function renderToolStart(kind, title) {
     return;
   }
   if (format === "json") {
-    writeLine(JSON.stringify({ type: "tool_start", kind, title }));
+    writeLine(JSON.stringify({ event: "tool_start", kind, title }));
     return;
   }
   const color = colorForKind(kind);
@@ -4016,7 +7321,7 @@ function renderToolComplete(kind) {
     return;
   }
   if (format === "json") {
-    writeLine(JSON.stringify({ type: "tool_complete", kind }));
+    writeLine(JSON.stringify({ event: "tool_complete", kind }));
     return;
   }
   const color = colorForKind(kind);
@@ -4029,7 +7334,7 @@ function renderReasoning(text4) {
     return;
   }
   if (format === "json") {
-    writeLine(JSON.stringify({ type: "reasoning", text: text4 }));
+    writeLine(JSON.stringify({ event: "reasoning", text: text4 }));
     return;
   }
   writeLine(chalk8.dim(`  \u2713 ${truncate(text4, 80)}`));
@@ -4048,10 +7353,10 @@ function renderUsage(tokens) {
   if (format === "json") {
     writeLine(
       JSON.stringify({
-        type: "usage",
-        input: tokens.input,
-        output: tokens.output,
-        cached: tokens.cached ?? 0,
+        event: "usage",
+        inputTokens: tokens.input,
+        outputTokens: tokens.output,
+        cachedTokens: tokens.cached ?? 0,
         costUsd: tokens.costUsd ?? 0
       })
     );
@@ -4066,7 +7371,7 @@ function renderError(message2) {
     return;
   }
   if (format === "json") {
-    writeLine(JSON.stringify({ type: "error", message: message2 }));
+    writeLine(JSON.stringify({ event: "error", message: message2 }));
     return;
   }
   writeLine(chalk8.red(`\u2717 ${message2}`));
@@ -4076,6 +7381,7 @@ var init_components = __esm({
   "packages/design-system/src/acp/components.ts"() {
     "use strict";
     init_output_format();
+    init_terminal_markdown();
     KIND_COLORS = {
       exec: (text4) => chalk8.yellow(text4),
       edit: (text4) => chalk8.magenta(text4),
@@ -4105,42 +7411,6 @@ var init_acp = __esm({
   }
 });
 
-// node_modules/fast-string-truncated-width/dist/utils.js
-var init_utils = __esm({
-  "node_modules/fast-string-truncated-width/dist/utils.js"() {
-  }
-});
-
-// node_modules/fast-string-truncated-width/dist/index.js
-var EMOJI_RE, MODIFIER_RE;
-var init_dist = __esm({
-  "node_modules/fast-string-truncated-width/dist/index.js"() {
-    init_utils();
-    EMOJI_RE = new RegExp("[\\u{1F1E6}-\\u{1F1FF}]{2}|\\u{1F3F4}[\\u{E0061}-\\u{E007A}]{2}[\\u{E0030}-\\u{E0039}\\u{E0061}-\\u{E007A}]{1,3}\\u{E007F}|(?:\\p{Emoji}\\uFE0F\\u20E3?|\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation})(?:\\u200D(?:\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation}|\\p{Emoji}\\uFE0F\\u20E3?))*", "yu");
-    MODIFIER_RE = new RegExp("\\p{M}+", "gu");
-  }
-});
-
-// node_modules/fast-string-width/dist/index.js
-var init_dist2 = __esm({
-  "node_modules/fast-string-width/dist/index.js"() {
-    init_dist();
-  }
-});
-
-// node_modules/fast-wrap-ansi/lib/main.js
-var ANSI_ESCAPE_BELL, ANSI_CSI, ANSI_OSC, ANSI_ESCAPE_LINK, GROUP_REGEX;
-var init_main = __esm({
-  "node_modules/fast-wrap-ansi/lib/main.js"() {
-    init_dist2();
-    ANSI_ESCAPE_BELL = "\x07";
-    ANSI_CSI = "[";
-    ANSI_OSC = "]";
-    ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
-    GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, "y");
-  }
-});
-
 // node_modules/sisteransi/src/index.js
 var require_src = __commonJS({
   "node_modules/sisteransi/src/index.js"(exports, module) {
@@ -4149,16 +7419,16 @@ var require_src = __commonJS({
     var CSI = `${ESC}[`;
     var beep = "\x07";
     var cursor = {
-      to(x, y2) {
-        if (!y2) return `${CSI}${x + 1}G`;
-        return `${CSI}${y2 + 1};${x + 1}H`;
+      to(x, y) {
+        if (!y) return `${CSI}${x + 1}G`;
+        return `${CSI}${y + 1};${x + 1}H`;
       },
-      move(x, y2) {
+      move(x, y) {
         let ret = "";
         if (x < 0) ret += `${CSI}${-x}D`;
         else if (x > 0) ret += `${CSI}${x}C`;
-        if (y2 < 0) ret += `${CSI}${-y2}A`;
-        else if (y2 > 0) ret += `${CSI}${y2}B`;
+        if (y < 0) ret += `${CSI}${-y}A`;
+        else if (y > 0) ret += `${CSI}${y}B`;
         return ret;
       },
       up: (count = 1) => `${CSI}${count}A`,
@@ -4198,24 +7468,30 @@ var require_src = __commonJS({
 });
 
 // node_modules/@clack/core/dist/index.mjs
-import { styleText as y } from "node:util";
-import { stdout as S, stdin as $ } from "node:process";
-import * as _ from "node:readline";
-import P from "node:readline";
-import { ReadStream as D } from "node:tty";
-function q(r) {
-  return r === C;
-}
-var import_sisteransi, E, G, u, Y, C;
-var init_dist3 = __esm({
+import { stdout as R, stdin as q } from "node:process";
+import * as k from "node:readline";
+import ot from "node:readline";
+import { ReadStream as J } from "node:tty";
+function Ct(t) {
+  return t === z;
+}
+var import_sisteransi, P, ct, pt, ft, j, Q, dt, U, et, At, _, bt, z;
+var init_dist = __esm({
   "node_modules/@clack/core/dist/index.mjs"() {
-    init_main();
     import_sisteransi = __toESM(require_src(), 1);
-    E = ["up", "down", "left", "right", "space", "enter", "cancel"];
-    G = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
-    u = { actions: new Set(E), aliases: /* @__PURE__ */ new Map([["k", "up"], ["j", "down"], ["h", "left"], ["l", "right"], ["", "cancel"], ["escape", "cancel"]]), messages: { cancel: "Canceled", error: "Something went wrong" }, withGuide: true, date: { monthNames: [...G], messages: { required: "Please enter a valid date", invalidMonth: "There are only 12 months in a year", invalidDay: (r, t) => `There are only ${r} days in ${t}`, afterMin: (r) => `Date must be on or after ${r.toISOString().slice(0, 10)}`, beforeMax: (r) => `Date must be on or before ${r.toISOString().slice(0, 10)}` } } };
-    Y = globalThis.process.platform.startsWith("win");
-    C = /* @__PURE__ */ Symbol("clack:cancel");
+    P = new RegExp("[\\u{1F1E6}-\\u{1F1FF}]{2}|\\u{1F3F4}[\\u{E0061}-\\u{E007A}]{2}[\\u{E0030}-\\u{E0039}\\u{E0061}-\\u{E007A}]{1,3}\\u{E007F}|(?:\\p{Emoji}\\uFE0F\\u20E3?|\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation})(?:\\u200D(?:\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation}|\\p{Emoji}\\uFE0F\\u20E3?))*", "yu");
+    ct = new RegExp("\\p{M}+", "gu");
+    pt = { limit: 1 / 0, ellipsis: "" };
+    ft = { limit: 1 / 0, ellipsis: "", ellipsisWidth: 0 };
+    j = "\x07";
+    Q = "[";
+    dt = "]";
+    U = `${dt}8;;`;
+    et = new RegExp(`(?:\\${Q}(?<code>\\d+)m|\\${U}(?<uri>.*)${j})`, "y");
+    At = ["up", "down", "left", "right", "space", "enter", "cancel"];
+    _ = { actions: new Set(At), aliases: /* @__PURE__ */ new Map([["k", "up"], ["j", "down"], ["h", "left"], ["l", "right"], ["", "cancel"], ["escape", "cancel"]]), messages: { cancel: "Canceled", error: "Something went wrong" }, withGuide: true };
+    bt = globalThis.process.platform.startsWith("win");
+    z = /* @__PURE__ */ Symbol("clack:cancel");
   }
 });
 
@@ -4232,7 +7508,7 @@ function cancel(msg = "") {
 var init_cancel = __esm({
   "packages/design-system/src/prompts/primitives/cancel.ts"() {
     "use strict";
-    init_dist3();
+    init_dist();
     init_output_format();
   }
 });
@@ -4605,6 +7881,7 @@ var init_src5 = __esm({
     init_theme();
     init_static();
     init_static();
+    init_terminal_markdown();
     init_theme_detect();
     init_output_format();
   }
@@ -4696,7 +7973,7 @@ async function renderAcpStream(events) {
   }
   flushAll();
 }
-var init_renderer = __esm({
+var init_renderer2 = __esm({
   "packages/agent-spawn/src/acp/renderer.ts"() {
     "use strict";
     init_src5();
@@ -4718,7 +7995,7 @@ function extractThreadId(value) {
   const maybeThreadId = isNonEmptyString(obj.thread_id) && obj.thread_id || isNonEmptyString(obj.threadId) && obj.threadId || isNonEmptyString(obj.threadID) && obj.threadID || isNonEmptyString(obj.session_id) && obj.session_id || isNonEmptyString(obj.sessionId) && obj.sessionId || isNonEmptyString(obj.sessionID) && obj.sessionID;
   return maybeThreadId || void 0;
 }
-var init_utils2 = __esm({
+var init_utils = __esm({
   "packages/agent-spawn/src/adapters/utils.ts"() {
     "use strict";
   }
@@ -4835,7 +8112,7 @@ var TOOL_KIND_MAP, TITLE_KEYS;
 var init_claude = __esm({
   "packages/agent-spawn/src/adapters/claude.ts"() {
     "use strict";
-    init_utils2();
+    init_utils();
     TOOL_KIND_MAP = {
       Read: "read",
       Write: "edit",
@@ -4897,7 +8174,8 @@ async function* adaptCodex(lines) {
       continue;
     }
     if (eventType === "turn.failed") {
-      yield { event: "error", message: "Turn failed" };
+      const message2 = extractErrorMessage(event) ?? "Turn failed";
+      yield { event: "error", message: message2 };
       continue;
     }
     const item = event.item ?? null;
@@ -4955,10 +8233,21 @@ async function* adaptCodex(lines) {
     }
   }
 }
+function extractErrorMessage(event) {
+  if (isNonEmptyString(event.message)) return event.message;
+  const error2 = event.error;
+  if (isNonEmptyString(error2)) return error2;
+  if (typeof error2 === "object" && error2 !== null) {
+    const errorObj = error2;
+    if (isNonEmptyString(errorObj.message)) return errorObj.message;
+  }
+  if (isNonEmptyString(event.reason)) return event.reason;
+  return void 0;
+}
 var init_codex3 = __esm({
   "packages/agent-spawn/src/adapters/codex.ts"() {
     "use strict";
-    init_utils2();
+    init_utils();
   }
 });
 
@@ -4998,7 +8287,7 @@ async function* adaptKimi(lines) {
 var init_kimi3 = __esm({
   "packages/agent-spawn/src/adapters/kimi.ts"() {
     "use strict";
-    init_utils2();
+    init_utils();
   }
 });
 
@@ -5033,7 +8322,7 @@ async function* adaptNative(lines) {
 var init_native = __esm({
   "packages/agent-spawn/src/adapters/native.ts"() {
     "use strict";
-    init_utils2();
+    init_utils();
   }
 });
 
@@ -5149,7 +8438,7 @@ async function* adaptOpenCode(lines) {
 var init_opencode3 = __esm({
   "packages/agent-spawn/src/adapters/opencode.ts"() {
     "use strict";
-    init_utils2();
+    init_utils();
   }
 });
 
@@ -5396,7 +8685,7 @@ var init_types2 = __esm({
 function isObjectRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function hasOwn(value, property) {
+function hasOwn2(value, property) {
   return Object.prototype.hasOwnProperty.call(value, property);
 }
 function isRequestId(value) {
@@ -5427,7 +8716,7 @@ function isJsonRpcErrorObject(value) {
   if (!isAcpErrorCode(value.code) || typeof value.message !== "string") {
     return false;
   }
-  return value.data === void 0 || hasOwn(value, "data");
+  return value.data === void 0 || hasOwn2(value, "data");
 }
 function toResponseError(error2) {
   return new AcpError(error2.code, error2.message, error2.data);
@@ -5525,8 +8814,8 @@ function parseJsonRpcMessage(line) {
       error: invalidRequest()
     };
   }
-  const hasMethod = hasOwn(parsed, "method");
-  const hasId = hasOwn(parsed, "id");
+  const hasMethod = hasOwn2(parsed, "method");
+  const hasId = hasOwn2(parsed, "id");
   if (hasMethod) {
     if (typeof parsed.method !== "string") {
       return {
@@ -5548,7 +8837,7 @@ function parseJsonRpcMessage(line) {
         id: parsed.id,
         method: parsed.method
       };
-      if (hasOwn(parsed, "params")) {
+      if (hasOwn2(parsed, "params")) {
         request.params = parsed.params;
       }
       return { type: "request", message: request };
@@ -5557,7 +8846,7 @@ function parseJsonRpcMessage(line) {
       jsonrpc: "2.0",
       method: parsed.method
     };
-    if (hasOwn(parsed, "params")) {
+    if (hasOwn2(parsed, "params")) {
       notification.params = parsed.params;
     }
     return {
@@ -5572,8 +8861,8 @@ function parseJsonRpcMessage(line) {
       error: invalidRequest()
     };
   }
-  const hasResult = hasOwn(parsed, "result");
-  const hasError = hasOwn(parsed, "error");
+  const hasResult = hasOwn2(parsed, "result");
+  const hasError = hasOwn2(parsed, "error");
   if (hasResult === hasError) {
     return {
       type: "invalid",
@@ -7151,8 +10440,8 @@ function normalizeAgent(agent2) {
     const code = char.charCodeAt(0);
     const isLower = code >= 97 && code <= 122;
     const isUpper = code >= 65 && code <= 90;
-    const isDigit = code >= 48 && code <= 57;
-    if (isLower || isUpper || isDigit || char === "-" || char === "_") {
+    const isDigit3 = code >= 48 && code <= 57;
+    if (isLower || isUpper || isDigit3 || char === "-" || char === "_") {
       normalized += char;
     } else {
       normalized += "-";
@@ -7263,7 +10552,7 @@ var init_src7 = __esm({
     init_spawn();
     init_spawn();
     init_spawn_interactive();
-    init_renderer();
+    init_renderer2();
     init_spawn2();
     init_spawn_acp();
     init_line_reader();
@@ -8647,7 +11936,7 @@ var init_errors = __esm({
 
 // src/cli/logger.ts
 import chalk18 from "chalk";
-function wrapText(text4, maxWidth) {
+function wrapText2(text4, maxWidth) {
   const words = text4.split(" ");
   const lines = [];
   let currentLine = "";
@@ -8813,7 +12102,7 @@ function createLoggerFactory(emitter, theme) {
           return;
         }
         const maxWidth = Math.min(process.stdout.columns || 80, 80) - 6;
-        const wrapped = steps.map((step) => wrapText(step, maxWidth)).join("\n");
+        const wrapped = steps.map((step) => wrapText2(step, maxWidth)).join("\n");
         note(wrapped, "Next steps.");
       },
       feedback(label, url) {
@@ -9764,7 +13053,7 @@ function createAbortError4() {
   error2.name = "AbortError";
   return error2;
 }
-var init_utils3 = __esm({
+var init_utils2 = __esm({
   "packages/pipeline/src/utils.ts"() {
     "use strict";
   }
@@ -9772,7 +13061,7 @@ var init_utils3 = __esm({
 
 // packages/pipeline/src/config/loader.ts
 import path14 from "node:path";
-import { parse as parse4 } from "yaml";
+import { parse as parse5 } from "yaml";
 function asStepMode(value) {
   if (value === void 0 || value === null) {
     return "yolo";
@@ -9784,7 +13073,7 @@ function asStepMode(value) {
 }
 function parseYamlDocument(filePath, content) {
   try {
-    return parse4(content);
+    return parse5(content);
   } catch (error2) {
     const message2 = error2 instanceof Error ? error2.message : String(error2);
     throw new Error(`Invalid pipeline step config YAML in "${filePath}": ${message2}`);
@@ -9890,12 +13179,12 @@ async function loadResolvedSteps(options) {
 var init_loader = __esm({
   "packages/pipeline/src/config/loader.ts"() {
     "use strict";
-    init_utils3();
+    init_utils2();
   }
 });
 
 // packages/pipeline/src/plan/parser.ts
-import { parse as parse5 } from "yaml";
+import { parse as parse6 } from "yaml";
 function asRequiredString(value, field) {
   if (typeof value === "string" && value.length > 0) {
     return value;
@@ -9979,7 +13268,7 @@ function parseMcpConfig(value) {
 function parsePlan(yamlContent, options = {}) {
   let document;
   try {
-    document = parse5(yamlContent);
+    document = parse6(yamlContent);
   } catch (error2) {
     const message2 = error2 instanceof Error ? error2.message : String(error2);
     throw new Error(`Invalid plan YAML: ${message2}`);
@@ -10033,10 +13322,10 @@ function parsePlan(yamlContent, options = {}) {
     ...mcp !== void 0 ? { mcp } : {}
   };
 }
-var init_parser = __esm({
+var init_parser2 = __esm({
   "packages/pipeline/src/plan/parser.ts"() {
     "use strict";
-    init_utils3();
+    init_utils2();
   }
 });
 
@@ -10212,8 +13501,8 @@ var init_discovery = __esm({
   "packages/pipeline/src/plan/discovery.ts"() {
     "use strict";
     init_loader();
-    init_parser();
-    init_utils3();
+    init_parser2();
+    init_utils2();
   }
 });
 
@@ -10658,6 +13947,30 @@ async function runPipeline(options) {
         };
       }
       if (selection.kind === "blocked") {
+        const retry = options.onBlocked ? await options.onBlocked({
+          taskId: selection.task.id,
+          ...selection.stepName ? { stepName: selection.stepName } : {}
+        }) : false;
+        if (retry) {
+          await writeTaskStatus({
+            fs: fs3,
+            planPath: absolutePlanPath,
+            taskId: selection.task.id,
+            ...selection.stepName ? { stepName: selection.stepName } : {},
+            status: "open"
+          });
+          if (lastGoodPlan) {
+            const cachedTask = lastGoodPlan.tasks.find((t) => t.id === selection.task.id);
+            if (cachedTask) {
+              if (selection.stepName && typeof cachedTask.status === "object") {
+                cachedTask.status[selection.stepName] = "open";
+              } else {
+                cachedTask.status = "open";
+              }
+            }
+          }
+          continue;
+        }
         return {
           stopReason: "failed",
           planPath,
@@ -10791,10 +14104,10 @@ var init_pipeline = __esm({
     init_loader();
     init_lock();
     init_discovery();
-    init_parser();
+    init_parser2();
     init_writer();
     init_runner();
-    init_utils3();
+    init_utils2();
   }
 });
 
@@ -10804,7 +14117,7 @@ var init_src10 = __esm({
     "use strict";
     init_loader();
     init_discovery();
-    init_parser();
+    init_parser2();
     init_writer();
     init_runner();
     init_pipeline();
@@ -11169,7 +14482,7 @@ function waitForTcp(check, signal) {
         finish(false);
         return;
       }
-      retryTimer = setTimeout(attemptConnection, Math.min(500, remainingMs));
+      retryTimer = setTimeout(attemptConnection, Math.min(100, remainingMs));
     }
     function clearActiveSocket(socket) {
       if (activeSocket === socket) {
@@ -12446,7 +15759,7 @@ var init_src12 = __esm({
 });
 
 // packages/ralph/src/frontmatter/frontmatter.ts
-import { parse as parse6, stringify } from "yaml";
+import { parse as parse7, stringify } from "yaml";
 function parseFrontmatter(content) {
   if (!content.startsWith(`${FENCE}
 `)) {
@@ -12466,7 +15779,7 @@ ${FENCE}
   }
   const yamlBlock = content.slice(FENCE.length + 1, closingIndex);
   const body = content.slice(closingIndex + FENCE.length + 2);
-  const parsed = parse6(yamlBlock);
+  const parsed = parse7(yamlBlock);
   return {
     data: parseFrontmatterData(parsed),
     body
@@ -12561,7 +15874,7 @@ function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var FENCE, DEFAULT_STATUS;
-var init_frontmatter = __esm({
+var init_frontmatter2 = __esm({
   "packages/ralph/src/frontmatter/frontmatter.ts"() {
     "use strict";
     FENCE = "---";
@@ -12663,6 +15976,18 @@ var init_discovery2 = __esm({
   }
 });
 
+// packages/ralph/src/variables/variables.ts
+function interpolateVariables(template, variables) {
+  return template.replace(/\{\{\s*(\w+)\s*\}\}/g, (match, name) => {
+    return name in variables ? variables[name] : match;
+  });
+}
+var init_variables = __esm({
+  "packages/ralph/src/variables/variables.ts"() {
+    "use strict";
+  }
+});
+
 // packages/ralph/src/run/ralph.ts
 import path24 from "node:path";
 import * as fsPromises6 from "node:fs/promises";
@@ -12682,13 +16007,16 @@ async function runRalph(options) {
     options.homeDir
   );
   const rawContent = await fs3.readFile(absoluteDocPath, "utf8");
-  const { data: frontmatter, body: prompt } = parseFrontmatter(rawContent);
+  const { data: frontmatter, body: rawBody } = parseFrontmatter(rawContent);
+  const prompt = interpolateVariables(rawBody, {
+    current_file: absoluteDocPath
+  });
   const startTime = Date.now();
   let iterationsCompleted = 0;
   await updateFrontmatter(
     fs3,
     absoluteDocPath,
-    prompt,
+    rawBody,
     frontmatter,
     "in_progress",
     0
@@ -12698,7 +16026,7 @@ async function runRalph(options) {
     await updateFrontmatter(
       fs3,
       absoluteDocPath,
-      prompt,
+      rawBody,
       frontmatter,
       status,
       iterationsCompleted
@@ -12740,7 +16068,7 @@ async function runRalph(options) {
       await updateFrontmatter(
         fs3,
         absoluteDocPath,
-        prompt,
+        rawBody,
         frontmatter,
         "in_progress",
         iterationsCompleted
@@ -12850,7 +16178,8 @@ var init_ralph = __esm({
   "packages/ralph/src/run/ralph.ts"() {
     "use strict";
     init_src2();
-    init_frontmatter();
+    init_frontmatter2();
+    init_variables();
   }
 });
 
@@ -12858,9 +16187,10 @@ var init_ralph = __esm({
 var init_src13 = __esm({
   "packages/ralph/src/index.ts"() {
     "use strict";
-    init_frontmatter();
+    init_frontmatter2();
     init_discovery2();
     init_ralph();
+    init_variables();
   }
 });
 
@@ -13005,7 +16335,7 @@ function parseNonNegativeInteger2(value) {
 function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var init_frontmatter2 = __esm({
+var init_frontmatter3 = __esm({
   "packages/experiment-loop/src/frontmatter/frontmatter.ts"() {
     "use strict";
   }
@@ -13013,14 +16343,8 @@ var init_frontmatter2 = __esm({
 
 // packages/experiment-loop/src/journal/journal.ts
 import { dirname as dirname2 } from "node:path";
-function baselineFromEntry(metrics, entry) {
-  if (entry.scores) {
-    return entry.scores;
-  }
-  if (entry.score !== null && metrics.length === 1) {
-    return { [metrics[0].name]: entry.score };
-  }
-  return null;
+function baselineFromEntry(entry) {
+  return entry.scores ?? null;
 }
 function parseLine(line) {
   try {
@@ -13053,14 +16377,12 @@ var TSV_HEADER, ExperimentJournal;
 var init_journal = __esm({
   "packages/experiment-loop/src/journal/journal.ts"() {
     "use strict";
-    TSV_HEADER = ["commit", "status", "score", "durationMs", "timestamp", "output", "agentOutput"].join("	");
+    TSV_HEADER = ["commit", "status", "scores", "durationMs", "timestamp", "output", "agentOutput"].join("	");
     ExperimentJournal = class {
       constructor(journalPath, fs3) {
         this.journalPath = journalPath;
         this.fs = fs3;
       }
-      journalPath;
-      fs;
       async init() {
         await this.fs.mkdir(dirname2(this.journalPath), { recursive: true });
         try {
@@ -13111,7 +16433,7 @@ var init_journal = __esm({
             (entry) => [
               entry.commit,
               entry.status,
-              entry.score === null ? "null" : String(entry.score),
+              entry.scores ? JSON.stringify(entry.scores) : "-",
               String(entry.durationMs),
               entry.timestamp,
               formatOutput(entry.output),
@@ -13217,7 +16539,7 @@ var init_git = __esm({
 import path25 from "node:path";
 import { readFile as readFile5 } from "node:fs/promises";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { parse as parse7 } from "yaml";
+import { parse as parse8 } from "yaml";
 function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -13234,7 +16556,7 @@ async function readOptionalFile2(fs3, filePath) {
 function parseRunConfigDocument(filePath, content) {
   let document;
   try {
-    document = parse7(content);
+    document = parse8(content);
   } catch (error2) {
     const message2 = error2 instanceof Error ? error2.message : String(error2);
     throw new Error(`Invalid experiment run config YAML in "${filePath}": ${message2}`);
@@ -13441,13 +16763,13 @@ function baselineFromResults(metrics, results) {
     })
   );
 }
-function deriveStateFromJournal(entries, metrics) {
+function deriveStateFromJournal(entries) {
   const keepEntries = entries.filter((e) => e.status === "keep");
   const lastKeep = keepEntries[keepEntries.length - 1];
   return {
     experimentsCompleted: entries.length,
     experimentsKept: keepEntries.length,
-    baseline: lastKeep ? baselineFromEntry(metrics, lastKeep) : null,
+    baseline: lastKeep ? baselineFromEntry(lastKeep) : null,
     baselineHash: lastKeep?.commit
   };
 }
@@ -13474,7 +16796,7 @@ async function runExperimentLoop(options) {
   const { frontmatter: initialFrontmatter } = await readDoc();
   const initialMetrics = normalizeMetrics(initialFrontmatter.metric);
   const journalEntries = await journal.readAll();
-  const journalState = deriveStateFromJournal(journalEntries, initialMetrics);
+  const journalState = deriveStateFromJournal(journalEntries);
   let experimentsCompleted = journalState.experimentsCompleted;
   let experimentsKept = journalState.experimentsKept;
   let baselineHash = journalState.baselineHash;
@@ -13551,7 +16873,7 @@ async function runExperimentLoop(options) {
       const journalAfter = await journal.readAll();
       let newEntry = journalAfter.length > journalLengthBefore ? journalAfter[journalAfter.length - 1] : null;
       experimentsCompleted += 1;
-      if (newEntry && newEntry.score === null && !newEntry.scores && metrics.length > 0) {
+      if (newEntry && !newEntry.scores && metrics.length > 0) {
         const metricTimeoutMs = frontmatter.metricTimeout ? frontmatter.metricTimeout * 1e3 : void 0;
         const results = await evaluateChain(
           metrics,
@@ -13562,15 +16884,14 @@ async function runExperimentLoop(options) {
         );
         if (allMetricsPassed(metrics, results)) {
           const scores = baselineFromResults(metrics, results);
-          const score = metrics.length === 1 ? results[0].score : null;
-          newEntry = await journal.updateLast({ score, scores }) ?? newEntry;
+          newEntry = await journal.updateLast({ scores }) ?? newEntry;
         }
       }
       if (newEntry) {
         if (newEntry.status === "keep") {
           experimentsKept += 1;
           baselineHash = newEntry.commit;
-          baseline = baselineFromEntry(metrics, newEntry) ?? baseline;
+          baseline = baselineFromEntry(newEntry) ?? baseline;
           options.onCommit?.(newEntry.commit);
         } else {
           await git.reset(preExperimentHash, options.cwd);
@@ -13593,7 +16914,7 @@ async function runExperimentLoop(options) {
 var init_loop = __esm({
   "packages/experiment-loop/src/run/loop.ts"() {
     "use strict";
-    init_frontmatter2();
+    init_frontmatter3();
     init_git();
     init_journal();
     init_evaluator();
@@ -13607,7 +16928,7 @@ var init_src14 = __esm({
   "packages/experiment-loop/src/index.ts"() {
     "use strict";
     init_types3();
-    init_frontmatter2();
+    init_frontmatter3();
     init_journal();
     init_evaluator();
     init_git();
@@ -13864,7 +17185,7 @@ var init_client_instance = __esm({
 });
 
 // packages/github-workflows/src/frontmatter.ts
-import { parse as parse8 } from "yaml";
+import { parse as parse9 } from "yaml";
 function parseFrontmatter2(markdown) {
   const content = markdown.startsWith("\uFEFF") ? markdown.slice(1) : markdown;
   const openingLineBreak = readOpeningLineBreak(content);
@@ -13931,7 +17252,7 @@ function parseYamlFrontmatter(yamlBlock) {
   const normalizedYamlBlock = yamlBlock.includes("\r") ? yamlBlock.replaceAll("\r\n", "\n").replaceAll("\r", "") : yamlBlock;
   let parsed;
   try {
-    parsed = parse8(normalizedYamlBlock);
+    parsed = parse9(normalizedYamlBlock);
   } catch (error2) {
     const message2 = error2 instanceof Error ? error2.message : "Unknown YAML parse error";
     throw new Error(`Invalid YAML frontmatter: ${message2}`);
@@ -13947,7 +17268,7 @@ function parseYamlFrontmatter(yamlBlock) {
 function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var init_frontmatter3 = __esm({
+var init_frontmatter4 = __esm({
   "packages/github-workflows/src/frontmatter.ts"() {
     "use strict";
   }
@@ -14138,7 +17459,7 @@ var VALID_AUTHOR_ASSOCIATIONS;
 var init_discover = __esm({
   "packages/github-workflows/src/discover.ts"() {
     "use strict";
-    init_frontmatter3();
+    init_frontmatter4();
     VALID_AUTHOR_ASSOCIATIONS = /* @__PURE__ */ new Set([
       "COLLABORATOR",
       "CONTRIBUTOR",
@@ -14162,11 +17483,11 @@ function assertValidEnumValues(values) {
     throw new Error("Enum schema values must be unique");
   }
 }
-var S2;
+var S;
 var init_src15 = __esm({
   "packages/cmdkit-schema/src/index.ts"() {
     "use strict";
-    S2 = {
+    S = {
       String(options = {}) {
         return {
           kind: "string",
@@ -14931,7 +18252,7 @@ async function selectAutomationName(message2, automations) {
     message: message2,
     options: automations.map((a) => ({ label: a.label ?? formatLabel(a.name), value: a.name }))
   });
-  if (q(selected)) {
+  if (Ct(selected)) {
     cancel("Operation cancelled.");
     throw new UserError("Operation cancelled.");
   }
@@ -14972,12 +18293,12 @@ var init_commands = __esm({
       name: "run",
       description: "Run a GitHub automation.",
       positional: ["name"],
-      params: S2.Object({
-        name: S2.Optional(S2.String()),
-        agent: S2.Optional(S2.String()),
-        model: S2.Optional(S2.String()),
-        mode: S2.Optional(S2.Enum(["yolo", "edit", "read"])),
-        cwd: S2.Optional(S2.String())
+      params: S.Object({
+        name: S.Optional(S.String()),
+        agent: S.Optional(S.String()),
+        model: S.Optional(S.String()),
+        mode: S.Optional(S.Enum(["yolo", "edit", "read"])),
+        cwd: S.Optional(S.String())
       }),
       secrets: {
         poeApiKey: { env: "POE_API_KEY" },
@@ -15057,13 +18378,13 @@ var init_commands = __esm({
     listCommand = defineCommand({
       name: "list",
       description: "List available automations.",
-      params: S2.Object({}),
+      params: S.Object({}),
       scope: ["cli", "sdk"],
       handler: async () => discoverAutomations(await resolveBuiltInPromptsDir(), ...projectPromptDirs(resolveCwd())),
       render: {
-        rich: (automations, { logger: logger2, renderTable: renderTable2, getTheme: getTheme2 }) => {
+        rich: (automations, { logger: logger2, renderTable: renderTable3, getTheme: getTheme2 }) => {
           logger2.message(
-            renderTable2({
+            renderTable3({
               theme: getTheme2(),
               columns: [
                 { name: "name", title: "Name", alignment: "left", maxLen: 40 },
@@ -15085,15 +18406,15 @@ var init_commands = __esm({
       name: "install",
       description: "Install an automation workflow into the current repo.",
       positional: ["name"],
-      params: S2.Object({
-        name: S2.Enum(installableAutomations, {
+      params: S.Object({
+        name: S.Enum(installableAutomations, {
           description: "Pick a GitHub workflow to install",
           loadOptions: async () => {
             const automations = await discoverAutomations(await resolveBuiltInPromptsDir());
             return automations.map((a) => ({ label: a.label ?? formatLabel(a.name), value: a.name }));
           }
         }),
-        eject: S2.Optional(S2.Boolean())
+        eject: S.Optional(S.Boolean())
       }),
       scope: ["cli"],
       handler: async ({ params }) => {
@@ -15140,8 +18461,8 @@ var init_commands = __esm({
       name: "uninstall",
       description: "Remove an installed automation workflow from the current repo.",
       positional: ["name"],
-      params: S2.Object({
-        name: S2.Enum(installableAutomations, {
+      params: S.Object({
+        name: S.Enum(installableAutomations, {
           description: "Pick a GitHub workflow to uninstall",
           loadOptions: async () => {
             const automations = await discoverAutomations(await resolveBuiltInPromptsDir());
@@ -15175,8 +18496,8 @@ var init_commands = __esm({
       name: "require-user-allow",
       description: "Fail when COMMENT_AUTHOR_ASSOCIATION is not allowed by the automation frontmatter.",
       positional: ["name"],
-      params: S2.Object({
-        name: S2.String()
+      params: S.Object({
+        name: S.String()
       }),
       scope: ["cli"],
       handler: async ({ params, env }) => {
@@ -15189,8 +18510,8 @@ var init_commands = __esm({
       name: "require-comment-prefix",
       description: "Fail when COMMENT_BODY does not start with the automation prefix frontmatter.",
       positional: ["name"],
-      params: S2.Object({
-        name: S2.String()
+      params: S.Object({
+        name: S.String()
       }),
       scope: ["cli"],
       handler: async ({ params, env }) => {
@@ -15203,8 +18524,8 @@ var init_commands = __esm({
       name: "prepare",
       description: "Install and configure the agent required by a workflow automation.",
       positional: ["name"],
-      params: S2.Object({
-        name: S2.String()
+      params: S.Object({
+        name: S.String()
       }),
       scope: ["cli"],
       handler: async ({ params }) => {
@@ -15224,8 +18545,8 @@ var init_commands = __esm({
       name: "prompt-preview",
       description: "Preview the resolved prompt for an automation.",
       positional: ["name"],
-      params: S2.Object({
-        name: S2.String()
+      params: S.Object({
+        name: S.String()
       }),
       scope: ["cli", "sdk"],
       handler: async ({ params, env }) => {
@@ -15265,7 +18586,7 @@ var init_commands = __esm({
 var init_src17 = __esm({
   "packages/github-workflows/src/index.ts"() {
     "use strict";
-    init_frontmatter3();
+    init_frontmatter4();
     init_discover();
     init_commands();
     init_check_user_allow();
@@ -18018,7 +21339,7 @@ async function* readLines3(stream) {
 function isObjectRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function hasOwn2(value, property) {
+function hasOwn3(value, property) {
   return Object.prototype.hasOwnProperty.call(value, property);
 }
 function isRequestId2(value) {
@@ -18043,7 +21364,7 @@ function isJsonRpcErrorObject2(value) {
   if (typeof value.code !== "number" || typeof value.message !== "string") {
     return false;
   }
-  return value.data === void 0 || hasOwn2(value, "data");
+  return value.data === void 0 || hasOwn3(value, "data");
 }
 function parseJsonRpcPayload(parsed) {
   if (!isObjectRecord4(parsed)) {
@@ -18061,8 +21382,8 @@ function parseJsonRpcPayload(parsed) {
       error: invalidRequest2()
     };
   }
-  const hasMethod = hasOwn2(parsed, "method");
-  const hasId = hasOwn2(parsed, "id");
+  const hasMethod = hasOwn3(parsed, "method");
+  const hasId = hasOwn3(parsed, "id");
   if (hasMethod) {
     if (typeof parsed.method !== "string") {
       return {
@@ -18084,7 +21405,7 @@ function parseJsonRpcPayload(parsed) {
         id: parsed.id,
         method: parsed.method
       };
-      if (hasOwn2(parsed, "params")) {
+      if (hasOwn3(parsed, "params")) {
         request.params = parsed.params;
       }
       return {
@@ -18096,7 +21417,7 @@ function parseJsonRpcPayload(parsed) {
       jsonrpc: "2.0",
       method: parsed.method
     };
-    if (hasOwn2(parsed, "params")) {
+    if (hasOwn3(parsed, "params")) {
       notification.params = parsed.params;
     }
     return {
@@ -18111,8 +21432,8 @@ function parseJsonRpcPayload(parsed) {
       error: invalidRequest2()
     };
   }
-  const hasResult = hasOwn2(parsed, "result");
-  const hasError = hasOwn2(parsed, "error");
+  const hasResult = hasOwn3(parsed, "result");
+  const hasError = hasOwn3(parsed, "error");
   if (hasResult === hasError) {
     return {
       type: "invalid",
@@ -18256,7 +21577,7 @@ var init_internal = __esm({
           if (onLog === void 0 || !isObjectRecord4(params) || !isLogLevel(params.level)) {
             return;
           }
-          if (!hasOwn2(params, "data")) {
+          if (!hasOwn3(params, "data")) {
             return;
           }
           const message2 = {
@@ -20177,7 +23498,7 @@ function renderResult(command, result, output, primitives, write2 = (chunk) => {
 `);
   }
 }
-var init_renderer2 = __esm({
+var init_renderer3 = __esm({
   "packages/cmdkit/src/renderer.ts"() {
     "use strict";
   }
@@ -20768,7 +24089,7 @@ async function promptForField(field) {
       options,
       initialValue: field.hasDefault ? field.defaultValue : void 0
     });
-    if (q(selected)) {
+    if (Ct(selected)) {
       cancel("Operation cancelled.");
       throw new UserError("Operation cancelled.");
     }
@@ -20779,7 +24100,7 @@ async function promptForField(field) {
       message: field.displayPath,
       initialValue: field.hasDefault ? Boolean(field.defaultValue) : void 0
     });
-    if (q(selected)) {
+    if (Ct(selected)) {
       cancel("Operation cancelled.");
       throw new UserError("Operation cancelled.");
     }
@@ -20789,7 +24110,7 @@ async function promptForField(field) {
     message: field.displayPath,
     initialValue: field.hasDefault && field.defaultValue !== void 0 ? formatResolvedValue(field.defaultValue) : void 0
   });
-  if (q(entered)) {
+  if (Ct(entered)) {
     cancel("Operation cancelled.");
     throw new UserError("Operation cancelled.");
   }
@@ -21352,7 +24673,7 @@ async function executeCommand(state, services, requirementOptions) {
         message: "Proceed?",
         initialValue: true
       });
-      if (q(proceed)) {
+      if (Ct(proceed)) {
         cancel("Operation cancelled.");
         throw new UserError("Operation cancelled.");
       }
@@ -21437,7 +24758,7 @@ var init_cli = __esm({
     "use strict";
     init_src5();
     init_src16();
-    init_renderer2();
+    init_renderer3();
     RESERVED_SERVICE_NAMES = /* @__PURE__ */ new Set(["params", "secrets", "fetch", "fs", "env", "progress"]);
     HELP_FLAGS = /* @__PURE__ */ new Set(["--help", "-h"]);
     GLOBAL_LONG_OPTION_FLAGS = /* @__PURE__ */ new Set(["--preset", "--yes", "--output", "--verbose"]);
@@ -21561,7 +24882,7 @@ function createCliContainer(dependencies) {
     checkAuth: async (apiKey) => await checkAuth({ apiKey }) !== null,
     confirm: async (message2) => {
       const result = await confirm2({ message: message2 });
-      if (q(result)) {
+      if (Ct(result)) {
         cancel("Operation cancelled.");
         throw new OperationCancelledError();
       }
@@ -22243,11 +25564,11 @@ function registerSpawnCommand(program, container, options = {}) {
         if (shouldEmitUiOutput) {
           const trimmedStdout = final.stdout.trim();
           if (trimmedStdout) {
-            resources.logger.info(trimmedStdout);
+            resources.logger.info(renderMarkdown(trimmedStdout).trimEnd());
           } else {
             const trimmedStderr = final.stderr.trim();
             if (trimmedStderr) {
-              resources.logger.info(trimmedStderr);
+              resources.logger.info(renderMarkdown(trimmedStderr).trimEnd());
             } else {
               resources.logger.info(`${adapter.label} spawn completed.`);
             }
@@ -22289,7 +25610,7 @@ async function confirmUnconfiguredService(container, service, label, flags) {
   const shouldProceed = await confirm2({
     message: `${label} is not configured via poe. Do you want to proceed?`
   });
-  if (q(shouldProceed)) {
+  if (Ct(shouldProceed)) {
     throw new OperationCancelledError();
   }
   return shouldProceed === true;
@@ -23021,7 +26342,7 @@ function registerUtilsCommand(program, container) {
   const utils = program.command("utils").description("Utility commands for inspecting and managing poe-code.");
   registerConfigCommand(utils, container);
 }
-var init_utils4 = __esm({
+var init_utils3 = __esm({
   "src/cli/commands/utils.ts"() {
     "use strict";
     init_config4();
@@ -23717,8 +27038,6 @@ var init_image = __esm({
         this.base64Data = base64Data;
         this.mimeType = mimeType;
       }
-      base64Data;
-      mimeType;
       static async fromUrl(url) {
         const response = await fetch(url);
         if (!response.ok) {
@@ -23793,8 +27112,6 @@ var init_audio = __esm({
         this.base64Data = base64Data;
         this.mimeType = mimeType;
       }
-      base64Data;
-      mimeType;
       static async fromUrl(url) {
         const response = await fetch(url);
         if (!response.ok) {
@@ -23865,10 +27182,6 @@ var init_file = __esm({
         this.isText = isText;
         this.name = name;
       }
-      data;
-      mimeType;
-      isText;
-      name;
       static async fromUrl(url) {
         const response = await fetch(url);
         if (!response.ok) {
@@ -25014,7 +28327,7 @@ function registerMcpCommand(program, container) {
           message: "Select agent to configure:",
           options: supportedAgents.map((a) => ({ value: a, label: a }))
         });
-        if (q(selected)) {
+        if (Ct(selected)) {
           cancel("Operation cancelled");
           return;
         }
@@ -25367,7 +28680,7 @@ function registerSkillCommand(program, container) {
           message: "Select agent to configure:",
           options: supportedAgents2.map((a) => ({ value: a, label: a }))
         });
-        if (q(selected)) {
+        if (Ct(selected)) {
           cancel("Operation cancelled");
           return;
         }
@@ -25400,7 +28713,7 @@ function registerSkillCommand(program, container) {
           { value: "local", label: "Local" }
         ]
       });
-      if (q(selected)) {
+      if (Ct(selected)) {
         cancel("Operation cancelled");
         return;
       }
@@ -25446,7 +28759,7 @@ function registerSkillCommand(program, container) {
         message: "Select agent to unconfigure:",
         options: supportedAgents2.map((a) => ({ value: a, label: a }))
       });
-      if (q(selected)) {
+      if (Ct(selected)) {
         cancel("Operation cancelled");
         return;
       }
@@ -25476,7 +28789,7 @@ function registerSkillCommand(program, container) {
           { value: "local", label: "Local" }
         ]
       });
-      if (q(selected)) {
+      if (Ct(selected)) {
         cancel("Operation cancelled");
         return;
       }
@@ -25839,7 +29152,7 @@ function registerUsageCommand(program, container) {
         startingAfter = result.data[result.data.length - 1].query_id;
         if (maxPages === void 0) {
           const shouldContinue = await confirm2({ message: "Load more?" });
-          if (q(shouldContinue)) {
+          if (Ct(shouldContinue)) {
             throw new OperationCancelledError();
           }
           if (!shouldContinue) {
@@ -26354,7 +29667,7 @@ function registerPipelineCommand(program, container) {
             label: value
           }))
         });
-        if (q(selected)) {
+        if (Ct(selected)) {
           cancel("Pipeline run cancelled.");
           return;
         }
@@ -26371,6 +29684,20 @@ function registerPipelineCommand(program, container) {
         ...options.plan ? { plan: options.plan } : {},
         ...resolveMaxRuns(options.maxRuns) != null ? { maxRuns: resolveMaxRuns(options.maxRuns) } : {},
         assumeYes: flags.assumeYes,
+        async onBlocked({ taskId, stepName }) {
+          if (flags.assumeYes) {
+            return true;
+          }
+          const label = stepName ? `${taskId} (${stepName})` : taskId;
+          const result2 = await confirm2({
+            message: `Previous run failed at ${label}. Retry?`,
+            initialValue: true
+          });
+          if (Ct(result2)) {
+            return false;
+          }
+          return result2 === true;
+        },
         onPlanReloadError(error2) {
           resources.logger.warn(`Plan reload failed, using last good state: ${error2.message}`);
         },
@@ -26386,7 +29713,7 @@ function registerPipelineCommand(program, container) {
         },
         selectPlan: async (input) => {
           const selected = await select2(input);
-          if (q(selected)) {
+          if (Ct(selected)) {
             cancel("Pipeline run cancelled.");
             return null;
           }
@@ -26394,7 +29721,7 @@ function registerPipelineCommand(program, container) {
         },
         promptForPath: async (input) => {
           const value = await text3(input);
-          if (q(value)) {
+          if (Ct(value)) {
             cancel("Pipeline run cancelled.");
             return null;
           }
@@ -26574,7 +29901,7 @@ function registerPipelineCommand(program, container) {
               label: value
             }))
           });
-          if (q(selected)) {
+          if (Ct(selected)) {
             cancel("Pipeline install cancelled.");
             return;
           }
@@ -26600,7 +29927,7 @@ function registerPipelineCommand(program, container) {
             { value: "global", label: "Global" }
           ]
         });
-        if (q(selected)) {
+        if (Ct(selected)) {
           cancel("Pipeline install cancelled.");
           return;
         }
@@ -26798,7 +30125,7 @@ async function resolveDocPath(options) {
       value: doc.path
     }))
   });
-  if (q(selected)) {
+  if (Ct(selected)) {
     cancel("Ralph run cancelled.");
     return null;
   }
@@ -26842,7 +30169,7 @@ async function promptForAgent(program) {
       value: config.agentId
     }))
   });
-  if (q(selected)) {
+  if (Ct(selected)) {
     cancel("Ralph run cancelled.");
     return null;
   }
@@ -26879,7 +30206,7 @@ async function resolveRunIterations(options) {
   const entered = await text3({
     message: "How many Ralph iterations should run?"
   });
-  if (q(entered)) {
+  if (Ct(entered)) {
     cancel("Ralph run cancelled.");
     return null;
   }
@@ -26909,7 +30236,7 @@ async function resolveInitIterations(options) {
   const entered = await text3({
     message: "How many Ralph iterations should run?"
   });
-  if (q(entered)) {
+  if (Ct(entered)) {
     cancel("Ralph init cancelled.");
     return null;
   }
@@ -27275,7 +30602,7 @@ async function resolveDocPath2(options) {
       value: doc.path
     }))
   });
-  if (q(selected)) {
+  if (Ct(selected)) {
     cancel(options.cancelMessage);
     return null;
   }
@@ -27305,7 +30632,7 @@ async function promptForAgent2(program) {
       value: config.agentId
     }))
   });
-  if (q(selected)) {
+  if (Ct(selected)) {
     cancel("Experiment run cancelled.");
     return null;
   }
@@ -27393,9 +30720,9 @@ function registerExperimentCommand(program, container) {
           resources.logger.info(`  Reset to ${targetHash.slice(0, 7)}`);
         },
         onExperimentComplete(index, entry) {
-          const score = entry.score === null ? "-" : String(entry.score);
+          const scores = entry.scores ? Object.entries(entry.scores).map(([k2, v]) => `${k2}=${v}`).join(", ") : "-";
           resources.logger.info(
-            `Experiment ${index} ${entry.status} in ${formatDuration3(entry.durationMs)} \xB7 score ${score}`
+            `Experiment ${index} ${entry.status} in ${formatDuration3(entry.durationMs)} \xB7 scores: ${scores}`
           );
         }
       });
@@ -27442,7 +30769,7 @@ function registerExperimentCommand(program, container) {
       const columns = [
         { name: "index", title: "#", alignment: "right", maxLen: 4 },
         { name: "status", title: "status", alignment: "left", maxLen: 8 },
-        { name: "score", title: "score", alignment: "right", maxLen: 10 },
+        { name: "scores", title: "scores", alignment: "left", maxLen: 40 },
         { name: "duration", title: "duration", alignment: "right", maxLen: 10 },
         { name: "timestamp", title: "timestamp", alignment: "left", maxLen: 24 },
         { name: "commit", title: "commit", alignment: "left", maxLen: 10 },
@@ -27451,7 +30778,7 @@ function registerExperimentCommand(program, container) {
       const rows = entries.map((entry, index) => ({
         index: String(index + 1),
         status: entry.status,
-        score: entry.score === null ? "-" : String(entry.score),
+        scores: entry.scores ? Object.entries(entry.scores).map(([k2, v]) => `${k2}=${v}`).join(", ") : "-",
         duration: formatDuration3(entry.durationMs),
         timestamp: entry.timestamp,
         commit: entry.commit,
@@ -27468,7 +30795,7 @@ function registerExperimentCommand(program, container) {
       resources.context.finalize();
     }
   });
-  journalCommand.command("log").description("Append an entry to the experiment journal.").argument("[doc]", "Experiment doc path").requiredOption("--status <status>", "Entry status: keep or discard").requiredOption("--commit <hash>", "Git commit hash").option("--score <number>", "Metric score (for single-metric display)").option("--scores <json>", `Multi-metric scores as JSON object, e.g. '{"tests":2}'`).option("--output <text>", "Metric output text", "").option("--duration-ms <number>", "Duration in milliseconds", "0").action(async function(docArg) {
+  journalCommand.command("log").description("Append an entry to the experiment journal.").argument("[doc]", "Experiment doc path").requiredOption("--status <status>", "Entry status: keep or discard").requiredOption("--commit <hash>", "Git commit hash").option("--scores <json>", `Metric scores as JSON object, e.g. '{"tests":2}'`).option("--output <text>", "Metric output text", "").option("--duration-ms <number>", "Duration in milliseconds", "0").action(async function(docArg) {
     const flags = resolveCommandFlags(program);
     const resources = createExecutionResources(container, flags, "experiment:journal:log");
     const opts = this.opts();
@@ -27487,7 +30814,6 @@ function registerExperimentCommand(program, container) {
       if (status !== "keep" && status !== "discard") {
         throw new ValidationError(`Invalid status "${opts.status}". Must be keep or discard.`);
       }
-      const score = opts.score !== void 0 ? Number.parseFloat(opts.score) : null;
       let scores;
       if (opts.scores) {
         try {
@@ -27499,7 +30825,6 @@ function registerExperimentCommand(program, container) {
       const entry = {
         commit: opts.commit,
         status,
-        score: score !== null && Number.isFinite(score) ? score : null,
         ...scores ? { scores } : {},
         output: opts.output,
         agentOutput: "",
@@ -27588,7 +30913,7 @@ function registerExperimentCommand(program, container) {
               label: value
             }))
           });
-          if (q(selected)) {
+          if (Ct(selected)) {
             cancel("Experiment install cancelled.");
             return;
           }
@@ -27614,7 +30939,7 @@ function registerExperimentCommand(program, container) {
             { value: "global", label: "Global" }
           ]
         });
-        if (q(selected)) {
+        if (Ct(selected)) {
           cancel("Experiment install cancelled.");
           return;
         }
@@ -27868,7 +31193,7 @@ async function resolveProcessId(value) {
   const entered = await text3({
     message: "Process ID"
   });
-  if (q(entered)) {
+  if (Ct(entered)) {
     cancel("Launch start cancelled.");
     return null;
   }
@@ -27885,7 +31210,7 @@ async function resolveCommandParts(commandArgs) {
   const entered = await text3({
     message: "Command to run"
   });
-  if (q(entered)) {
+  if (Ct(entered)) {
     cancel("Launch start cancelled.");
     return null;
   }
@@ -27909,7 +31234,7 @@ async function resolveRuntime(options) {
       { label: "docker", value: "docker" }
     ]
   });
-  if (q(selected)) {
+  if (Ct(selected)) {
     cancel("Launch start cancelled.");
     return null;
   }
@@ -27922,7 +31247,7 @@ async function resolveDockerImage(value) {
   const entered = await text3({
     message: "Docker image"
   });
-  if (q(entered)) {
+  if (Ct(entered)) {
     cancel("Launch start cancelled.");
     return null;
   }
@@ -27947,7 +31272,7 @@ async function resolveRestart(restart, assumeYes) {
       { label: "always", value: "always" }
     ]
   });
-  if (q(selected)) {
+  if (Ct(selected)) {
     cancel("Launch start cancelled.");
     return null;
   }
@@ -28125,7 +31450,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "poe-code",
-      version: "3.0.144",
+      version: "3.0.146",
       description: "CLI tool to configure Poe API for developer workflows.",
       type: "module",
       main: "./dist/index.js",
@@ -28675,7 +32000,7 @@ var init_program = __esm({
     init_login();
     init_logout();
     init_auth();
-    init_utils4();
+    init_utils3();
     init_install();
     init_unconfigure();
     init_test();
@@ -28716,7 +32041,7 @@ function createPromptRunner(adapter = {
   text: text3,
   password: password2,
   select: select2,
-  isCancel: q,
+  isCancel: Ct,
   cancel
 }) {
   const runPrompt = async (descriptor) => {