mdwire-core 0.1.11

//! 공개 API 의 행동. 코퍼스가 "실제로 겪은 고장"을 지킨다면, 여기는 규칙이 규칙대로
//! 도는지를 본다.

use mdwire::{render, Channel, Streamer};

fn one(input: &str, channel: Channel) -> String {
    let parts = render(input, channel);
    assert!(parts.len() <= 1, "이 입력은 나뉠 길이가 아니다: {parts:?}");
    parts.into_iter().next().unwrap_or_default()
}

fn tg(input: &str) -> String {
    one(input, Channel::TelegramHtml)
}

// ── 복구 ────────────────────────────────────────────────────────────────

#[test]
fn emphasis_spanning_a_line_break_is_one_range() {
    // 실제 모양(LLM 산출물 85줄 중 78줄) — 여는 마커는 보통 자리, 닫는 마커는 다음 줄.
    assert_eq!(
        tg("이번 주 결론은 **배포를 금요일에\n하지 않는다** 이고, 예외는 없다."),
        "이번 주 결론은 <b>배포를 금요일에\n하지 않는다</b> 이고, 예외는 없다."
    );
    // 정규식 변환기가 뒤집던 인위적 모양 — 줄 첫머리의 `**` 는 닫기가 아니라 **열기**다.
    // 먼저 열린 `채널**` 은 짝 잃은 마커라 버리고 둘째 줄이 온전한 굵게다. CommonMark 도
    // 슬랙(실측 2026-09-22)도 이렇게 읽는다 — 다른 점은 짝 잃은 `**` 를 글자로 남기지
    // 않는 것뿐이다.
    assert_eq!(
        tg("공개 채널**이다. 글 내용이 아니라\n**신분 공개 + 시점의 조합**이 판단 대상"),
        "공개 채널이다. 글 내용이 아니라\n<b>신분 공개 + 시점의 조합</b>이 판단 대상"
    );
}

#[test]
fn unclosed_emphasis_closes_at_block_end() {
    assert_eq!(tg("앞말 **굵은 꼬리"), "앞말 <b>굵은 꼬리</b>");
    // 블록을 넘지는 않는다. 다음 문단까지 굵어지면 뒤의 무관한 텍스트를 삼킨 것이다.
    assert_eq!(tg("**열고 끝\n\n다음 문단"), "<b>열고 끝</b>\n\n다음 문단");
}

#[test]
fn unclosed_code_fence_closes() {
    assert_eq!(tg("```\n코드 한 줄"), "<pre>코드 한 줄</pre>");
}

#[test]
fn lone_asterisks_stay_literal() {
    // `2 ** 3` 은 강조가 아니다. 추측으로 열었더라도 안 닫히면 되돌린다.
    assert_eq!(tg("2 ** 3 은 곱셈이 아니다"), "2 ** 3 은 곱셈이 아니다");
    // 홑마커 꼬리도 글자다 — 각주로 쓰인다.
    assert_eq!(tg("참고*"), "참고*");
}

/// **짝 잃은 `**` 는 버리고, 홑마커는 글자로 둔다.** 앞이 글자인 `**` 가 홀로 남을
/// 이유는 없다 — 닫으려던 마커고, 되돌리면 출력에 마커가 남는다. 홑마커는 다르다:
/// 각주(`참고*`)·글롭(`underfront.*`)·주석(`/* */`)으로 쓰이는 글자라 버리면 내용 손실이다.
/// 실측(LLM 산출물 430건)에서 사라진 별표는 전부 이쪽이었다.
#[test]
fn an_orphaned_double_marker_is_dropped_but_a_single_stays() {
    assert_eq!(tg("온다* 뒤에 더 있다"), "온다* 뒤에 더 있다");
    assert_eq!(tg("꼬리**"), "꼬리");
    assert_eq!(tg("underfront.* (4개), minjunkim.* (3개)"), "underfront.* (4개), minjunkim.* (3개)");
    // 추측으로 연 것은 뒤의 마커가 닫지 않는다 — 주석의 별표 둘 다 글자다. 그 뒤의
    // 진짜 기울임은 살아 있다.
    assert_eq!(tg("/* a */ 다음 *z* 끝"), "/* a */ 다음 <i>z</i> 끝");
    // 추측이 둘 겹쳐 있을 때 아래쪽이 물러나도 죽지 않는다 — 위쪽(홑마커)부터 정리한다.
    // `***` 는 어디에도 못 열린 한 덩어리라 셋 다 글자로 남는다 — 앞 조각 `**` 를 짝 잃은
    // 닫기로 보고 버리면 마스킹 번호(`4***-****`)의 별표가 사라진다.
    assert_eq!(tg("a*** **x"), "a*** <b>x</b>");
    // 마스킹 번호. 쪼갠 런의 남은 `*` 가 제 앞 별표를 앞 글자로 봐서 기울임을 열었다(실측).
    assert_eq!(tg("본인 4***-****-****-003* 확인"), "본인 4***-****-****-003* 확인");
    // 블록이 갈리면 강조는 넘어가지 않고, 넘어가려던 홑마커는 글자로 남는다.
    assert_eq!(
        tg("문단에서 *기울임이 열리고\n> 인용 줄이 온다* 뒤"),
        "문단에서 <i>기울임이 열리고</i>\n<blockquote>인용 줄이 온다* 뒤</blockquote>"
    );
}

#[test]
fn underscores_inside_identifiers_survive() {
    assert_eq!(tg("plain_text_name 은 그대로다"), "plain_text_name 은 그대로다");
}

/// 닫는 백틱을 찾을 때 **안 맞는 런은 통째로 건너뛴다.**
///
/// 한 글자씩 넘기면 길이 N+1 인 런 안에 길이 N 인 런이 들어 있는 꼴이 되어 그 안쪽에서
/// 잘못 닫힌다. CommonMark 스펙 테스트의 입력을 빌려 돌리다 잡았다.
#[test]
fn a_code_span_closes_on_a_run_of_the_same_length() {
    // 앞뒤 공백 하나는 마커와 떼어 놓으려고 끼운 것이라 내용이 아니다 — CommonMark 가
    // 한 쌍을 벗기라고 한다.
    assert_eq!(tg("` foo `` bar `"), "<code>foo `` bar</code>");
    assert_eq!(tg("` `` `"), "<code>``</code>");
    assert_eq!(tg("``백틱 ` 포함`` 밖"), "<code>백틱 ` 포함</code> 밖");
}

#[test]
fn markers_inside_code_are_text() {
    assert_eq!(tg("`**굵지 않다**` 그리고 밖"), "<code>**굵지 않다**</code> 그리고 밖");
}

/// **`**` 가 태그 채널의 출력에 남으면 그건 실패다.** 정상이라면 전부 변환됐어야 한다.
/// 이 고장이 몇 달을 간 이유가 "틀려도 채널이 200 을 준다" 였다.
#[test]
fn no_emphasis_marker_survives_into_tag_channels() {
    for input in [
        "공개 채널**이다. 글 내용이 아니라\n**신분 공개 + 시점의 조합**이 판단 대상",
        "**열기만** 하고 **닫지 않으면",
        "- **항목** 하나\n- 항목 **둘",
        "> 인용 안의 **강조**도",
        "# 헤딩의 **강조**",
    ] {
        for channel in [Channel::TelegramHtml, Channel::Plain] {
            let out = one(input, channel);
            assert!(!out.contains("**"), "{}: {out}", channel.name());
        }
    }
}

/// 한국어 출력에서 흔한 모양 — 강조 끝에 조사가 붙고 그 앞이 구두점이다.
///
/// CommonMark 은 "앞이 구두점이고 뒤가 글자면 닫을 수 없다"고 한다. 그 규칙을 그대로
/// 따르면 넷 다 안 닫히고 **강조가 블록 끝까지 번져 뒤의 무관한 텍스트를 삼킨다.**
#[test]
fn emphasis_closes_even_when_a_punctuation_precedes_the_marker() {
    assert_eq!(tg("**(중요)**이다"), "<b>(중요)</b>이다");
    assert_eq!(tg("**끝.**이라서 그렇다"), "<b>끝.</b>이라서 그렇다");
    assert_eq!(tg("**코드 `a`**였다"), "<b>코드 <code>a</code></b>였다");
    assert_eq!(
        tg("- 실패의 **99%가 `TIMEOUT`**이었고, 나머지는 달랐다"),
        "• 실패의 <b>99%가 <code>TIMEOUT</code></b>이었고, 나머지는 달랐다"
    );
}

/// 위 규칙을 풀면서도 **줄 첫머리의 여는 마커는 여전히 닫기가 아니어야 한다.**
/// 여기가 뒤집히면 그게 이 저장소가 존재하는 이유인 바로 그 고장이다 — 열기로 읽어
/// 먼저 열린 쪽을 물린다.
#[test]
fn a_marker_after_whitespace_still_never_closes() {
    assert_eq!(tg("채널**이다.\n**신분 공개**가 대상"), "채널이다.\n<b>신분 공개</b>가 대상");
    assert_eq!(tg("앞말 **강조**"), "앞말 <b>강조</b>");
}

/// 줄 넘는 강조는 **불릿 안에서도** 일어난다. 80열 wrap 은 항목이라고 봐주지 않는다.
/// 항목을 줄마다 끊으면 이 라이브러리의 첫 고장이 리스트 안에서만 그대로 남는다.
#[test]
fn emphasis_spans_a_wrapped_list_item() {
    assert_eq!(
        tg("- 앞말 **굵은 것이\n  다음 줄로 이어진다** 끝\n- 다음 항목"),
        "• 앞말 <b>굵은 것이\n  다음 줄로 이어진다</b> 끝\n• 다음 항목"
    );
    // 그래도 강조가 항목을 넘지는 않는다.
    assert_eq!(
        tg("- 열고 **안 닫음\n- 새 항목"),
        "• 열고 <b>안 닫음</b>\n• 새 항목"
    );
}

/// 물결표는 한국어에서 근사값과 범위에 늘 쓰인다. 취소선 입력은 `~~` 여야 한다 —
/// GFM 도 슬랙 `markdown_text` 도 그렇게 적는다.
#[test]
fn a_lone_tilde_is_text_not_strikethrough() {
    assert_eq!(tg("주행 ~40km 까지 ~22km 부족하다"), "주행 ~40km 까지 ~22km 부족하다");
    assert_eq!(tg("충전은 5~6월이다"), "충전은 5~6월이다");
    assert_eq!(tg("~~진짜 취소선~~ 이다"), "<s>진짜 취소선</s> 이다");
}

/// **취소선 표기는 채널마다 갈린다.** 하나로 뭉뚱그리면 한쪽은 취소선이 안 걸리고
/// 물결표만 보인다 — 슬랙 `markdown_text` 는 표준 마크다운이라 `~~` 를 받는다.
#[test]
fn strikethrough_uses_each_channels_own_syntax() {
    let input = "~~지난 계획~~ 은 접는다";
    assert_eq!(tg(input), "<s>지난 계획</s> 은 접는다");
    assert_eq!(one(input, Channel::SlackMarkdown), "~~지난 계획~~ 은 접는다");
    assert_eq!(one(input, Channel::Plain), "지난 계획 은 접는다");
    // 취소선 안의 강조도 살아남는다.
    assert_eq!(tg("~~취소선 안의 **굵게**~~"), "<s>취소선 안의 <b>굵게</b></s>");
}

/// 한도를 넘는 코드펜스를 쪼갤 때, 조각마다 `<pre><code class=…>` 가 제대로 닫히고
/// 다시 열려야 한다. 태그가 단어 경계에 걸려 추적을 놓치면 조각 하나가 통째로 깨진다.
#[test]
fn an_oversized_fence_keeps_its_tags_across_parts() {
    let body = (0..400).map(|i| format!("줄 {i} 내용이 길게 이어진다\n")).collect::<String>();
    let input = format!("```markdown\n{body}```\n");
    let parts = render(&input, Channel::TelegramHtml);
    assert!(parts.len() > 1);
    for part in &parts {
        assert!(part.chars().count() <= Channel::TelegramHtml.limit(), "{}자", part.chars().count());
        // balanced 는 여닫는 순서까지 본다 — `</pre>` 가 `</code>` 보다 먼저 오면 잡힌다.
        assert!(balanced(part), "조각이 깨졌다");
        assert!(part.starts_with("<pre>"), "이어지는 조각은 펜스를 다시 열어야 한다");
    }
}

/// 표는 **`|` 로 시작하는 줄**이면 앞 블록이 무엇이든 시작한다.
/// 빈 줄을 요구하면 인용문·리스트 바로 뒤에 붙은 표를 통째로 놓친다.
#[test]
fn a_table_can_start_right_after_any_block() {
    let table = "|  | 값 |\n|---|---|\n| 가 | 1 |";

    // 인용문 바로 뒤. 인용문을 닫고 표를 연다.
    let out = tg(&format!("> 인용이 먼저다.\n{table}"));
    assert!(out.starts_with("<blockquote>인용이 먼저다.</blockquote>"), "{out}");
    assert!(out.contains("<pre>"), "{out}");
    assert_eq!(out.matches("<blockquote>").count(), out.matches("</blockquote>").count());

    // 리스트 바로 뒤, 문단 바로 뒤.
    assert!(tg(&format!("- 항목\n{table}")).contains("<pre>"));
    assert!(tg(&format!("문단이 먼저다.\n{table}")).contains("<pre>"));

    // 문단 한가운데의 `|` 는 여전히 글자다.
    assert_eq!(one("문단 a | b 가 있다", Channel::Plain), "문단 a | b 가 있다");
}

#[test]
fn a_run_of_three_markers_leaves_nothing_behind() {
    // `***x***` 는 굵게 안에 기울임이다. 셋 중 무엇을 집든 별표가 출력에 남으면 실패다.
    assert_eq!(tg("***세 개 별표***"), "<b><i>세 개 별표</i></b>");
    assert_eq!(one("***세 개 별표***", Channel::SlackMarkdown), "***세 개 별표***");
    // 따로 적은 것과 같은 답이다.
    assert_eq!(tg("_**둘 다**_"), "<i><b>둘 다</b></i>");
    assert_eq!(tg("***여는 쪽만 셋**"), "<b><i>여는 쪽만 셋</i></b>");
    assert_eq!(tg("**닫는 쪽만 셋***"), "<b>닫는 쪽만 셋</b>");
}

#[test]
fn crlf_input_does_not_leak_carriage_returns() {
    let out = tg("윈도우 줄바꿈\r\n**굵게**\r\n");
    assert!(!out.contains('\r'), "{out:?}");
    assert_eq!(out, "윈도우 줄바꿈\n<b>굵게</b>");
}

/// `SPEC.md` 6절 — 각색은 하지 않는다. 체크박스를 ✅/⬜ 로 바꾸지 않는다.
#[test]
fn checkboxes_are_not_dressed_up() {
    assert_eq!(tg("- [ ] 안 한 일\n- [x] 한 일"), "• [ ] 안 한 일\n• [x] 한 일");
}

/// CJK 전반에서 닫는 마커가 먹어야 한다.
///
/// CommonMark 는 "앞이 구두점이고 뒤가 글자면 닫을 수 없다"고 정해 놨고, 중국어·일본어·
/// 한국어가 거기 정면으로 걸린다 — 셋 다 경계에 공백을 안 넣기 때문이다. 표준화 논의가
/// 진행 중인 알려진 결함이다(CommonMark 의 CJK-friendly 개정안).
#[test]
fn emphasis_closes_next_to_cjk_punctuation() {
    // 일본어 — 개정안 문서가 대표 예로 드는 모양
    assert_eq!(
        tg("**強調記号として認識されない。**この文のせいで。"),
        "<b>強調記号として認識されない。</b>この文のせいで。"
    );
    assert_eq!(tg("**「引用符」**です。"), "<b>「引用符」</b>です。");
    assert_eq!(tg("**（注釈）**は重要だ。"), "<b>（注釈）</b>は重要だ。");
    // 중국어
    assert_eq!(tg("**中文加粗，**后面接着中文。"), "<b>中文加粗，</b>后面接着中文。");
    // 한국어
    assert_eq!(tg("**끝.**이라서 그렇다."), "<b>끝.</b>이라서 그렇다.");
}

/// 따옴표로 시작하고 끝나는 강조 뒤에 조사가 붙는 모양.
///
/// **실제 글에서 아주 흔하다** — 인용을 굵게 처리하면 거의 항상 이 꼴이 된다.
/// 여는 쪽은 앞이 공백이라 문제가 없고, 닫는 쪽이 `"` 뒤 `로` 라서 CommonMark 가 막는다.
#[test]
fn emphasis_closes_after_a_quote_mark() {
    assert_eq!(
        tg(r#"잣대를 **"저자가 쓴 게 얼마나 살아남느냐"**로 둔다"#),
        r#"잣대를 <b>"저자가 쓴 게 얼마나 살아남느냐"</b>로 둔다"#
    );
    // 곡선 따옴표와 홑따옴표도 같다.
    assert_eq!(tg("**“곡선”**이라고"), "<b>“곡선”</b>이라고");
    assert_eq!(tg("**'홑'**을"), "<b>'홑'</b>을");
    // 닫는 마커 뒤가 마침표여도 닫힌다.
    assert_eq!(tg(r#"**"끝"**."#), r#"<b>"끝"</b>."#);
}

/// **복구 규칙은 언어를 가리지 않는다.**
///
/// CommonMark 의 CJK-friendly 개정안은 마커 뒤가 CJK 일 때만 닫게 해 주므로 영어에서는
/// 같은 모양이 그대로 깨진다. 우리 규칙은 "같은 종류가 열려 있고 앞이 공백이 아니면
/// 닫는다" 하나라서 언어와 무관하게 닫힌다 — 깨진 입력을 고치는 것이 목적이지
/// 특정 언어를 돕는 것이 목적이 아니다.
#[test]
fn the_repair_is_not_language_specific() {
    assert_eq!(tg(r#"the mark is **"what survives"**and not ours"#),
               r#"the mark is <b>"what survives"</b>and not ours"#);
    assert_eq!(tg("a **(note)**follows"), "a <b>(note)</b>follows");
}

// ── 블록 매핑 (SPEC 8절) ────────────────────────────────────────────────

#[test]
fn headings_map_per_channel() {
    assert_eq!(tg("## 제목"), "<b>제목</b>");
    assert_eq!(one("## 제목", Channel::SlackMarkdown), "## 제목");
    assert_eq!(one("## 제목", Channel::Plain), "제목");
}

#[test]
fn heading_levels_do_not_jump() {
    // 두 단계 이상 깊어지면 한 단계로 당긴다.
    assert_eq!(
        one("# 하나\n\n#### 넷", Channel::SlackMarkdown),
        "# 하나\n\n## 넷"
    );
}

#[test]
fn list_markers_are_unified() {
    assert_eq!(one("* 하나\n+ 둘\n- 셋", Channel::SlackMarkdown), "- 하나\n- 둘\n- 셋");
    assert_eq!(tg("* 하나\n+ 둘"), "• 하나\n• 둘");
    assert_eq!(one("3. 셋\n4. 넷", Channel::Plain), "3. 셋\n4. 넷");
}

#[test]
fn quotes_wrap_once_not_per_line() {
    assert_eq!(tg("> 한 줄\n> 두 줄"), "<blockquote>한 줄\n두 줄</blockquote>");
    assert_eq!(one("> 한 줄\n> 두 줄", Channel::Plain), "> 한 줄\n> 두 줄");
}

#[test]
fn fence_info_becomes_a_language_class() {
    assert_eq!(
        tg("```rust\nlet a = 1 < 2;\n```"),
        "<pre><code class=\"language-rust\">let a = 1 &lt; 2;</code></pre>"
    );
}

#[test]
fn links_render_per_channel() {
    let input = "[문서](https://example.com/a?b=1&c=2) 참고";
    assert_eq!(tg(input), "<a href=\"https://example.com/a?b=1&amp;c=2\">문서</a> 참고");
    assert_eq!(one(input, Channel::SlackMarkdown), input);
    assert_eq!(one(input, Channel::Plain), "문서 (https://example.com/a?b=1&c=2) 참고");
}

#[test]
fn html_special_characters_are_escaped() {
    assert_eq!(tg("a < b & c > d"), "a &lt; b &amp; c &gt; d");
}

// ── 정돈 ────────────────────────────────────────────────────────────────

#[test]
fn extra_blank_lines_collapse_to_one() {
    assert_eq!(tg("첫 문단\n\n\n\n\n둘째 문단"), "첫 문단\n\n둘째 문단");
}

#[test]
fn leading_and_trailing_blank_lines_go_away() {
    assert_eq!(tg("\n\n본문\n\n\n"), "본문");
}

// ── CJK 정책 ────────────────────────────────────────────────────────────

/// **한글 옆 마커에 아무것도 끼우지 않는다.** 슬랙 `markdown_text` 는 `**마통**이` 를
/// 그대로 굵게 그리고(실측 2026-09-22), 텔레그램 HTML 은 태그로 나간다 — 목표 채널 어디에도
/// U+200B 가 필요 없다. 끼우면 보이지 않는 글자가 복사에 딸려갈 뿐이다.
#[test]
fn nothing_is_padded_next_to_cjk() {
    let input = "채널**이다** 그리고 **강조**ｱｲｳ 와 `코드`글";
    for channel in Channel::all() {
        let out = render(input, channel).join("");
        assert!(!out.contains('\u{200b}'), "{}: {out:?}", channel.name());
    }
    assert_eq!(one("채널**이다", Channel::SlackMarkdown), "채널**이다**");
    assert_eq!(one("채널**이다", Channel::TelegramHtml), "채널<b>이다</b>");
}

/// **슬랙 `markdown_text` 의 기울임은 `*` 다.** `_기울임_가` 는 슬랙이 글자 그대로 두고
/// `*기울임*가` 는 기울인다(실측 2026-09-22). 패딩 없이 조사를 붙이려면 마커를 바꿔야 한다.
#[test]
fn slack_markdown_text_italic_uses_asterisk() {
    assert_eq!(one("_진료_가 있다", Channel::SlackMarkdown), "*진료*가 있다");
    assert_eq!(one("*진료*가 있다", Channel::SlackMarkdown), "*진료*가 있다");
    assert_eq!(one("~~취소~~가 있다", Channel::SlackMarkdown), "~~취소~~가 있다");
    assert_eq!(one("_진료_가 있다", Channel::TelegramHtml), "<i>진료</i>가 있다");
}

// ── 분할 ────────────────────────────────────────────────────────────────

#[test]
fn parts_stay_within_the_limit_and_keep_markup_whole() {
    let block = "**굵은 문단**이 하나 있고 `코드`도 있다. 이 문단은 길이 한도를 넘기려고 반복된다.\n\n";
    let input = block.repeat(80);
    let parts = render(&input, Channel::TelegramHtml);
    assert!(parts.len() > 1, "한도를 넘겼는데 안 나뉘었다");
    for part in &parts {
        assert!(part.chars().count() <= Channel::TelegramHtml.limit(), "조각이 한도를 넘는다");
        assert!(!part.contains("**"), "마커가 남았다");
        assert_eq!(part.matches("<b>").count(), part.matches("</b>").count(), "태그 짝이 안 맞는다");
        assert_eq!(part.matches("<code>").count(), part.matches("</code>").count());
        assert!(!part.starts_with('\n') && !part.ends_with('\n'), "조각 끝에 빈 줄이 남았다");
    }
}

#[test]
fn a_single_oversized_block_is_cut_with_tags_closed_and_reopened() {
    // 한 블록이 통째로 한도를 넘는 경우. 자르는 자리에서 닫고 다음 조각에서 다시 연다.
    let input = format!("> **{}**", "한글 ".repeat(3000));
    let parts = render(&input, Channel::TelegramHtml);
    assert!(parts.len() > 1);
    for part in &parts {
        assert!(part.chars().count() <= Channel::TelegramHtml.limit());
        assert_eq!(part.matches("<blockquote>").count(), part.matches("</blockquote>").count());
        assert_eq!(part.matches("<b>").count(), part.matches("</b>").count());
    }
}

// ── 스트리밍 ────────────────────────────────────────────────────────────

#[test]
fn chunk_boundary_inside_markup_does_not_leak() {
    let mut s = Streamer::new(Channel::TelegramHtml);
    let mut out = String::new();
    out.push_str(s.push("앞말 **굵"));
    // 강조가 아직 안 닫혔다. 여는 태그도 내용도 나가면 안 된다 —
    // 나가 버리면 뒤에 오는 무관한 텍스트를 삼킨다.
    assert_eq!(out, "앞말 ");
    out.push_str(s.push("게** 뒷말"));
    out.push_str(s.finish());
    assert_eq!(out, "앞말 <b>굵게</b> 뒷말");
}

#[test]
fn streaming_never_emits_half_a_tag() {
    let input = "# 제목\n\n**굵게** 있는 문단과 `코드` 그리고\n이어지는 **줄 넘는 강조**다.\n";
    for size in 1..=12 {
        let mut s = Streamer::new(Channel::TelegramHtml);
        let mut seen = String::new();
        for chunk in input.as_bytes().chunks(size) {
            // 바이트로 자르면 UTF-8 이 깨지므로 문자 단위로 다시 맞춘다.
            let _ = chunk;
        }
        let mut buf = String::new();
        for c in input.chars() {
            buf.push(c);
            if buf.chars().count() == size {
                let piece = s.push(&buf);
                assert!(!piece.contains('<') || piece.matches('<').count() == piece.matches('>').count());
                seen.push_str(piece);
                buf.clear();
            }
        }
        seen.push_str(s.push(&buf));
        seen.push_str(s.finish());
        assert_eq!(seen, render(input, Channel::TelegramHtml).join(""));
    }
}

/// **스트리밍 도중 아무 지점에서 끊어도 그 시점의 누적본을 보낼 수 있어야 한다.**
///
/// 인라인은 붙들려서 이미 균형이 맞지만 블록의 여는 마크업은 먼저 나간다.
/// `close_open` 을 덧붙인 결과가 모든 지점에서 균형이 맞는지 본다 — 안 맞으면
/// 그 시점에 보낸 메시지를 채널이 400 으로 거절한다.
#[test]
fn any_mid_stream_snapshot_is_sendable() {
    let input = "# 제목\n\n> 인용 안의 **강조**와\n> 이어지는 줄\n\n```rust\nlet a = 1;\nlet b = 2;\n```\n\n| 열 | 값 |\n|---|---|\n| 가 | 1 |\n\n끝 문단 **굵게**";
    let mut s = Streamer::new(Channel::TelegramHtml);
    let mut acc = String::new();
    let mut checked = 0;
    let mut raw_broken = 0;

    for c in input.chars() {
        let mut piece = [0u8; 4];
        s.push_into(c.encode_utf8(&mut piece), &mut acc);
        if !balanced(&acc) {
            raw_broken += 1;
        }
        let mut snapshot = acc.clone();
        s.close_open(&mut snapshot);
        assert!(balanced(&snapshot), "여기서 끊으면 못 보낸다: {snapshot:?}");
        checked += 1;
    }
    s.finish_into(&mut acc);
    assert!(balanced(&acc));
    assert!(checked > 50, "충분히 많은 지점을 봐야 한다");
    // close_open 없이는 실제로 깨지는 지점이 있어야 한다.
    // 하나도 없으면 이 테스트는 아무것도 지키지 않는 것이다.
    assert!(raw_broken > 0, "누적본이 늘 균형이 맞다면 close_open 은 필요 없는 API 다");
}

/// 태그가 짝이 맞고 순서대로 닫히는가. 채널이 보는 것과 같은 잣대다.
fn balanced(html: &str) -> bool {
    let mut stack: Vec<String> = Vec::new();
    let ch: Vec<char> = html.chars().collect();
    let mut i = 0;
    while i < ch.len() {
        if ch[i] != '<' {
            i += 1;
            continue;
        }
        let closing = ch.get(i + 1) == Some(&'/');
        let from = if closing { i + 2 } else { i + 1 };
        let mut j = from;
        while j < ch.len() && (ch[j].is_ascii_alphanumeric() || ch[j] == '-') {
            j += 1;
        }
        let name: String = ch[from..j].iter().collect();
        while j < ch.len() && ch[j] != '>' {
            j += 1;
        }
        if j >= ch.len() {
            return false; // 태그가 반으로 잘렸다
        }
        if closing {
            if stack.pop().as_deref() != Some(name.as_str()) {
                return false;
            }
        } else {
            stack.push(name);
        }
        i = j + 1;
    }
    stack.is_empty()
}

#[test]
fn empty_input_produces_nothing() {
    assert!(render("", Channel::TelegramHtml).is_empty());
    assert!(render("   \n\n  \n", Channel::TelegramHtml).is_empty());
}

/// **한도보다 긴 주소는 링크로 내지 않는다.**
///
/// `<a href="…">` 하나가 메시지 한 통을 다 차지하면, 조각을 아무리 나눠도 내용이 한
/// 글자도 안 들어간다. 예전에는 여기서 렌더가 끝나지 않았다. 링크를 포기하고 주소를
/// 글로 내보낸다 — 링크는 죽어도 내용은 산다.
#[test]
fn an_address_longer_than_the_limit_becomes_text() {
    let url = format!("https://example.com/{}", "x".repeat(5000));
    let parts = render(&format!("[아주 긴 링크]({url}) 뒤에 오는 글"), Channel::TelegramHtml);

    let joined = parts.join("");
    let preview: String = joined.chars().take(80).collect();
    assert!(!joined.contains("<a "), "링크로 내면 조각이 성립하지 않는다: {preview}");
    assert!(joined.contains("아주 긴 링크"), "링크 텍스트가 사라졌다");
    assert!(joined.contains("뒤에 오는 글"), "뒤쪽 내용이 사라졌다");
    for (i, p) in parts.iter().enumerate() {
        assert!(p.chars().count() <= Channel::TelegramHtml.limit(), "조각 {i} 가 한도를 넘었다");
        assert!(balanced(p), "조각 {i} 의 태그가 안 맞는다");
    }

    // 한도 안쪽 주소는 그대로 링크다.
    let ok = render("[링크](https://example.com/x) 뒤", Channel::TelegramHtml);
    assert!(ok[0].contains("<a href=\"https://example.com/x\">링크</a>"), "{:?}", ok[0]);
}

/// 맨몸 링크는 라벨이 곧 주소다. **escape 차이로 다르다고 보면 주소를 두 번 낸다.**
#[test]
fn an_over_limit_bare_link_is_not_written_twice() {
    let url = format!("https://example.com/?q={}&x=1", "y".repeat(5000));
    let parts = render(&format!("[{url}]({url})"), Channel::TelegramHtml);
    let joined = parts.join("");
    assert_eq!(joined.matches("&amp;x=1").count(), 1, "주소가 두 번 나왔다");
}

/// **짝 없는 백틱 런은 글자다.**
///
/// 코드로 삼켜서 블록 끝까지 닫아 버리면, 뒤에 오던 강조가 통째로 코드 안에 갇힌다.
/// 실제 문서에서 `앞 ``` 뒤에 **굵게**` 의 굵게가 사라지고 있었다.
#[test]
fn an_unpaired_backtick_run_is_text_and_what_follows_still_emphasizes() {
    let got = one("앞부분 ``` 뒤에 **굵게** 가 온다", Channel::TelegramHtml);
    assert_eq!(got, "앞부분 ``` 뒤에 <b>굵게</b> 가 온다");

    // 짝이 맞는 런은 그대로 코드다.
    let got = one("앞 `코드` 와 **굵게**", Channel::TelegramHtml);
    assert_eq!(got, "앞 <code>코드</code> 와 <b>굵게</b>");

    // 긴 런도 짝이 맞으면 코드다.
    let got = one("앞 ``코드 `안` 에`` 와 **굵게**", Channel::TelegramHtml);
    assert_eq!(got, "앞 <code>코드 `안` 에</code> 와 <b>굵게</b>");
}

/// 되돌려 다시 읽을 때 **줄 사이의 구분자도 그대로 있어야 한다.**
///
/// 줄바꿈·인용 접두사·항목 들여쓰기는 블록 층이 출력에 바로 쓴다. 코드 스팬 내용에
/// 같이 안 남겨 두면 되돌릴 때 두 줄이 한 줄로 붙는다.
#[test]
fn replaying_an_unpaired_code_span_keeps_line_breaks() {
    let got = one("앞 `foo\nbar **굵게**", Channel::TelegramHtml);
    assert_eq!(got, "앞 `foo\nbar <b>굵게</b>");

    let got = one("> 인용 `foo\n> bar 뒤", Channel::SlackMarkdown);
    assert_eq!(got, "> 인용 `foo\n> bar 뒤");

    let got = one("- 항목 `foo\n  bar 뒤", Channel::Plain);
    assert_eq!(got, "• 항목 `foo\n  bar 뒤");
}

/// **표에서 넘치는 칸을 버리지 않는다.**
///
/// 칸 안의 `|` 가 칸을 가르면 머리글보다 칸이 많아지는데, GFM 은 넘치는 것을 잘라
/// 낸다. 그러면 저자가 쓴 마지막 칸이 소리 없이 사라진다.
#[test]
fn a_row_with_extra_cells_keeps_them() {
    let input = "| A | B |\n| --- | --- |\n| `x|y` | 뒤쪽 내용 |\n";
    let got = one(input, Channel::Plain);
    assert!(got.contains("뒤쪽 내용"), "넘친 칸이 사라졌다: {got}");

    // 칸 수가 맞는 표는 그대로다.
    let plain = one("| A | B |\n| --- | --- |\n| 하나 | 둘 |\n", Channel::Plain);
    assert!(plain.contains("하나") && plain.contains("둘"), "{plain}");
}

/// **역슬래시 이스케이프.** `\_` 는 밑줄 한 글자지 강조 마커가 아니다.
#[test]
fn a_backslash_escape_makes_the_next_character_plain() {
    assert_eq!(one(r"TEST\_VCLEFT\_FRONT", Channel::TelegramHtml), "TEST_VCLEFT_FRONT");
    assert_eq!(one(r"2 \* 3 과 **굵게**", Channel::TelegramHtml), "2 * 3 과 <b>굵게</b>");
    // 이스케이프된 대괄호는 링크를 열지 않는다.
    assert_eq!(one(r"new createError\[code\](\[msg\])", Channel::Plain), "new createError[code]([msg])");
    // 코드 스팬 안에서는 이스케이프가 없다. 역슬래시도 내용이다.
    assert_eq!(one(r"`코드\_안`", Channel::TelegramHtml), r"<code>코드\_안</code>");
    // 마크다운을 그대로 내보내는 채널은 이스케이프를 지킨다 — 벗기면 뜻이 바뀐다.
    assert_eq!(one(r"2 \* 3", Channel::SlackMarkdown), r"2 \* 3");
}

/// 백틱을 담은 코드 스팬. **울타리를 늘리고 앞뒤 공백 하나를 벗긴다.**
#[test]
fn a_code_span_holding_a_backtick_widens_its_fence() {
    // 마크다운 채널: 백틱 하나로 감싸면 ``` 가 되어 코드 블록으로 읽힌다.
    let got = one("백틱(`` ` ``)으로", Channel::SlackMarkdown);
    assert_eq!(got, "백틱(`` ` ``)으로");

    // HTML 채널: 울타리가 필요 없고 공백만 벗긴다.
    assert_eq!(one("백틱(`` ` ``)으로", Channel::TelegramHtml), "백틱(<code>`</code>)으로");

    // 마커를 지우는 채널은 공백이 곧 낱말 경계라 벗기지 않는다.
    assert_eq!(one("백틱(`` ` ``)으로", Channel::Plain), "백틱( ` )으로");
}

/// 탭만 든 코드 스팬은 바깥 공백을 벗긴다. `trim` 은 탭도 털어서 못 가른다.
#[test]
fn a_tab_only_body_still_loses_its_padding_spaces() {
    assert_eq!(one("가 ` \t ` 나", Channel::TelegramHtml), "가 <code>\t</code> 나");
    // 진짜로 공백뿐이면 그대로 둔다 — 벗길 것이 내용밖에 없다.
    assert_eq!(one("가 `  ` 나", Channel::TelegramHtml), "가 <code>  </code> 나");
}

/// **슬랙 `markdown_text` 는 표를 직접 그린다.** 고정폭으로 내리면 화면에서 코드로 보인다.
/// GFM 그대로 낸다 — 정렬 표시와 셀 안의 마크업, `\|` 까지.
#[test]
fn slack_markdown_text_keeps_tables_as_gfm() {
    let input = "| 항목 | 값 | 비고 |\n|:--|--:|:-:|\n| **마통** | 0원 | a\\|b |\n";
    assert_eq!(
        one(input, Channel::SlackMarkdown),
        "| 항목 | 값 | 비고 |\n| --- | ---: | :---: |\n| **마통** | 0원 | a\\|b |"
    );
    // 못 그리는 채널은 여전히 고정폭이다.
    assert!(one(input, Channel::TelegramHtml).starts_with("<pre>"));
}

/// **`<https://…>` 오토링크.** mrkdwn 습관이 남은 LLM 이 자주 쓴다(한 표본에서 124건).
/// 텔레그램은 `&lt;` 로 이스케이프하면 화면에 꺾쇠가 글자로 보인다 — 링크로 낸다.
#[test]
fn angle_autolink_becomes_a_link() {
    let input = "주소는 <https://a.com/x_y_z?q=1&r=2> 다";
    assert_eq!(
        one(input, Channel::TelegramHtml),
        "주소는 <a href=\"https://a.com/x_y_z?q=1&amp;r=2\">https://a.com/x_y_z?q=1&amp;r=2</a> 다"
    );
    assert_eq!(one(input, Channel::SlackMarkdown), "주소는 <https://a.com/x_y_z?q=1&r=2> 다");
    assert_eq!(one(input, Channel::Plain), "주소는 https://a.com/x_y_z?q=1&r=2 다");
    // 안에 공백이 있으면 링크가 아니다.
    assert_eq!(one("<https://a.com/x y>", Channel::Plain), "<https://a.com/x y>");
    // `<url|텍스트>` — 슬랙 레거시 링크. 슬랙에서 긁어 온 글에 그대로 남는다.
    let legacy = "<https://a.com/p|문서 보기> 참고";
    assert_eq!(one(legacy, Channel::SlackMarkdown), "[문서 보기](https://a.com/p) 참고");
    assert_eq!(one(legacy, Channel::TelegramHtml), "<a href=\"https://a.com/p\">문서 보기</a> 참고");
    assert_eq!(one(legacy, Channel::Plain), "문서 보기 (https://a.com/p) 참고");
}

/// **마크다운에 없는 표현을 메운 HTML 은 태그만 벗긴다.** `<sub>`·`<br>` 이 실측된
/// 것들이다. 텔레그램은 모르는 태그에 400 을 주고, 슬랙 `markdown_text` 도 그리지 않는다.
/// 벗기지 않으면 화면에 `<sub>` 가 글자로 보인다. 모르는 꺾쇠(`Vec<T>`, `1 < 2`)는 글이다.
#[test]
fn known_html_tags_are_stripped_and_unknown_angles_kept() {
    let input = "H<sub>2</sub>O 와 <B>굵</B> Vec<T> 1 < 2 <!-- 주석 --> 끝";
    assert_eq!(one(input, Channel::TelegramHtml), "H2O 와 굵 Vec&lt;T&gt; 1 &lt; 2  끝");
    assert_eq!(one(input, Channel::SlackMarkdown), "H2O 와 굵 Vec<T> 1 < 2  끝");
    // `<br>` 은 줄바꿈이다. 벗겨 버리면 두 줄이 붙는다.
    assert_eq!(one("첫째<br>둘째<br/>셋째", Channel::TelegramHtml), "첫째\n둘째\n셋째");
    // 링크 태그는 벗기지 않는다 — 벗기면 주소가 사라진다.
    assert_eq!(one("<a href=\"u\">t</a>", Channel::SlackMarkdown), "<a href=\"u\">t</a>");
}

/// **GitHub 은 홑 `~` 를 취소선으로, `<T>` 를 태그로 읽는다**(실측 2026-09-30, `POST /markdown`).
/// 글자로 남은 둘은 이스케이프해 낸다 — `약 ~40km, 5~6월` 이 그어지고 `Vec<T>` 의 `T` 가 지워지던
/// 것이다. 코드 안은 이스케이프가 글자로 보이니 그대로 두고, 진짜 취소선 `~~` 도 그대로다.
#[test]
fn github_escapes_tilde_and_angle_outside_code() {
    let g = |s| one(s, Channel::GithubMarkdown);
    assert_eq!(g("약 ~40km, 5~6월 이동"), r"약 \~40km, 5\~6월 이동");
    assert_eq!(g("Vec<T> 와 1 < 2"), r"Vec\<T> 와 1 \< 2");
    assert_eq!(g("~~취소~~가 `a~b <T>`"), "~~취소~~가 `a~b <T>`");
    assert_eq!(g("```\nx ~ <y>\n```"), "```\nx ~ <y>\n```");
    // 저자가 이스케이프해 둔 것은 한 번만 이스케이프한다.
    assert_eq!(g(r"5\~6월 \<T>"), r"5\~6월 \<T>");
    // 표 칸도 본문이다.
    assert_eq!(g("| a~b |\n|---|\n| <T> |"), "| a\\~b |\n| --- |\n| \\<T> |");
    // 오토링크·링크 주소는 건드리지 않는다.
    assert_eq!(g("<https://a.com/~me>"), "<https://a.com/~me>");
    // 헤딩은 여섯 단계를 다 그린다.
    assert_eq!(g("# 하나\n\n## 둘\n\n### 셋\n\n#### 넷"), "# 하나\n\n## 둘\n\n### 셋\n\n#### 넷");
}

/// **노션은 GitHub 과 같은 마크다운에서 출발하되 반대로 가는 곳이 있다**(실측 2026-10-01, 커넥터로
/// 페이지를 만들고 되읽었다). 조사 앞 강조는 노션이 그대로 그려 `<strong>` 으로 바꾸지 않고, 인라인
/// HTML 은 글자로 보여서 벗긴다. 마스킹 번호의 `*` 와 홀로 쓴 `\` 는 노션이 먹어서 이스케이프하고,
/// `~`·`<` 는 글자로 그려 둔다. `<url>` 은 꺾쇠가 글자로 남아 링크 문법으로 쓴다.
#[test]
fn notion_escapes_what_it_eats_and_strips_tags() {
    let n = |s| one(s, Channel::NotionMarkdown);
    assert_eq!(n("**설정(config)**을 바꾼다"), "**설정(config)**을 바꾼다");
    assert_eq!(n("H<sub>2</sub>O 와 <kbd>C</kbd>"), "H2O 와 C");
    assert_eq!(n("카드 1***-****-001* 끝"), r"카드 1\*\*\*-\*\*\*\*-001\* 끝");
    assert_eq!(n(r"백슬래시 \ 하나"), r"백슬래시 \\ 하나");
    assert_eq!(n("약 ~40km, Vec<T>"), "약 ~40km, Vec<T>");
    // 저자가 이스케이프해 둔 것은 한 번만, 코드 안은 그대로.
    assert_eq!(n(r"\*별\* `a*b\c`"), r"\*별\* `a*b\c`");
    assert_eq!(n("<https://a.com/x_y>"), r"[https://a.com/x\_y](https://a.com/x_y)");
    assert_eq!(n("##### 다섯\n\n* 별표 목록"), "#### 다섯\n\n- 별표 목록");
    // 자체 리뷰에서 나온 것들 — 노션에 다시 올려 재 봤다.
    // `<br>` 은 그린다(칸 안에서도) — `\n` 으로 바꾸면 인용이 갈린다.
    assert_eq!(n("> **a<br>b** 끝"), "> **a<br>b** 끝");
    assert_eq!(
        n("| a |\n|---|\n| 줄<br>바꿈 |"),
        "<table header-row=\"true\">\n<tr>\n<td>a</td>\n</tr>\n<tr>\n<td>줄<br>바꿈</td>\n</tr>\n</table>"
    );
    // 줄 끝 역슬래시는 글자로 둔다(이스케이프한다) — 노션에 하드 브레이크 문법이 없고, 지우면 문단 끝의
    // `C:\` 같은 글자까지 사라진다.
    assert_eq!(n("foo\\\nbar"), "foo\\\\\nbar");
    assert_eq!(n(r"path C:\"), r"path C:\\");
    // `\$` 는 지킨다 — 벗기면 `$x$` 가 수식이 된다.
    assert_eq!(n(r"\$x\$ 와 $5"), r"\$x\$ 와 $5");
    // 오토링크 라벨의 마커 글자는 이스케이프하고, 주소의 괄호는 퍼센트로.
    assert_eq!(n("<https://a.com/*x*>"), r"[https://a.com/\*x\*](https://a.com/*x*)");
    assert_eq!(n("<https://a.com/x)>"), "[https://a.com/x)](https://a.com/x%29)");
}

/// **노션은 줄을 넘는 강조의 짝을 못 맞춘다**(실측 2026-10-01) — `**줄을\n넘는 굵게**` 는 `**` 가
/// 비쳤고, 인용·목록 안에서는 굵게가 통째로 사라졌다. 줄마다 닫고, 다음 줄은 접두사 뒤에서 다시 연다.
#[test]
fn notion_closes_emphasis_at_each_line() {
    let n = |s| one(s, Channel::NotionMarkdown);
    assert_eq!(n("**줄을\n넘는 굵게**와 끝"), "**줄을**\n**넘는 굵게**와 끝");
    assert_eq!(n("> **인용\n> 안의** 굵게"), "> **인용**\n> **안의** 굵게");
    assert_eq!(n("- **항목\n  이어짐** 끝\n- 둘"), "- **항목**\n  **이어짐** 끝\n- 둘");
    assert_eq!(n("*기울임 **굵게\n이어짐** 끝*"), "*기울임 **굵게***\n***이어짐** 끝*");
    assert_eq!(n("`코드\n이어짐`"), "`코드`\n`이어짐`");
    // 백틱이 든 코드 스팬도 줄마다 — 울타리는 그 줄의 가장 긴 런보다 하나 길게.
    assert_eq!(n("`a``\nb`"), "``` a`` ```\n`b`");
    // 줄 끝 공백은 닫는 마커 밖으로 — 공백 뒤의 `**` 는 닫기가 아니다.
    assert_eq!(n("**끝 \n다음**"), "**끝**\n**다음**");
    // 줄을 넘는 링크는 노션도 링크로 읽지 않는다(대괄호가 글자로 남는다, 실측) — 줄마다 감싸야
    // 굵게라도 산다. 안 감싸면 굵게가 통째로 사라졌다.
    assert_eq!(n("**[링크\n이어](http://x.com)**"), "**[링크**\n**이어](http://x.com)**");
    // 다른 채널은 그대로다.
    assert_eq!(one("**줄을\n넘는**", Channel::GithubMarkdown), "**줄을\n넘는**");
}

/// **노션에는 표를 `<table>` 로 낸다**(실측 2026-10-01). 파이프 표로 내면 칸 안의 `|` 가 — 코드
/// 스팬 안이든 `\|` 로 이스케이프했든 — 칸을 갈라 뒤의 내용이 사라졌다. `<table>` 에서는 글자다.
#[test]
fn notion_writes_tables_as_xml() {
    let out = one("| 항목 | 비고 |\n|:--|--:|\n| **마통** | a \\| b |", Channel::NotionMarkdown);
    assert_eq!(
        out,
        "<table header-row=\"true\">\n<tr>\n<td>항목</td>\n<td>비고</td>\n</tr>\n<tr>\n<td>**마통**</td>\n<td>a | b</td>\n</tr>\n</table>"
    );
}

/// **한도를 넘는 노션 표는 머리글을 되풀이한 표 여럿으로 나눈다.** 분할기는 태그를 모르고 줄로
/// 끊어서, 한 표를 가르면 앞 조각은 `</table>` 없이 끝나고 뒤 조각은 `<tr>` 로 시작했다.
#[test]
fn notion_splits_long_tables_into_whole_tables() {
    let mut input = String::from("| a | b |\n|---|---|\n");
    for i in 0..40 {
        input.push_str(&format!("| 행{i} | 값{i} 가나다라 |\n"));
    }
    let opts = mdwire::Options { limit: Some(300), ..Default::default() };
    let parts = mdwire::render_with(&input, Channel::NotionMarkdown, opts).parts;
    assert!(parts.len() > 1);
    for p in &parts {
        assert!(p.chars().count() <= 300, "{p}");
        assert!(p.starts_with("<table header-row=\"true\">\n<tr>\n<td>a</td>") && p.ends_with("</table>"), "{p}");
    }
    // 머리글과 함께 한도에 안 드는 행은 표 밖의 글로 내린다 — 표는 조각마다 온전하다.
    let long = format!("| 머리 | 둘 |\n|---|---|\n| 짧음 | 가 |\n| {} | 나 |\n| 짧음2 | 다 |", "긴칸".repeat(200));
    let opts = mdwire::Options { limit: Some(300), ..Default::default() };
    let parts = mdwire::render_with(&long, Channel::NotionMarkdown, opts).parts;
    for p in &parts {
        assert!(p.chars().count() <= 300);
        assert_eq!(p.matches("<table ").count(), p.matches("</table>").count(), "{p}");
    }
    assert!(parts.concat().contains("긴칸긴칸 | 나"));
    // 칸에 글자로 적힌 태그 모양은 이스케이프한다 — `</td>` 가 칸을 닫았다.
    assert_eq!(
        one("| a |\n|---|\n| x </td> y <br> z |", Channel::NotionMarkdown),
        "<table header-row=\"true\">\n<tr>\n<td>a</td>\n</tr>\n<tr>\n<td>x \\<\\/td\\> y <br> z</td>\n</tr>\n</table>"
    );
    // 두 번째 자체 리뷰: 닫히지 않는 꺾쇠(`i<n`)는 태그가 아니라 뒤의 `<br>` 을 건드리지 않고, 코드
    // 안의 `<T>` 는 그대로(코드 안의 이스케이프는 글자로 보인다) — 칸을 깨는 `</td>` 만 막는다.
    let cells = one("| a | b |\n|---|---|\n| i<n 일 때<br>반복 | `Option<T>` 와 `x</td>y` |", Channel::NotionMarkdown);
    assert!(cells.contains("<td>i<n 일 때<br>반복</td>"), "{cells}");
    assert!(cells.contains(r"<td>`Option<T>` 와 `x\<\/td\>y`</td>"), "{cells}");
    // 행이 전부 글로 내려가도 머리글은 남고, 글로 내린 줄의 첫머리는 이스케이프한다.
    let only = format!("| 이름 | 설명 |\n|---|---|\n| # 제목처럼 | {} |", "가 ".repeat(200));
    let opts = mdwire::Options { limit: Some(256), ..Default::default() };
    let out = mdwire::render_with(&only, Channel::NotionMarkdown, opts).parts.concat();
    assert!(out.starts_with("이름 | 설명\n\\# 제목처럼 | 가 가"), "{out}");
    // 스트리밍은 채널 한도(65,536)로 재므로 이 크기는 표 하나다.
    let mut s = mdwire::Streamer::new(Channel::NotionMarkdown);
    let mut acc = String::new();
    s.push_into(&input, &mut acc);
    s.finish_into(&mut acc);
    assert_eq!(acc.matches("<table ").count(), 1);
}

/// **보고는 채널에 맞춰 바꾼 것도 센다**(실사용 보고 — GitHub 코멘트 44개 중 22개의 출력이 달라졌는데
/// 보고는 1건이었다). 붙이기 전에 무엇이 바뀌는지 보는 데 쓴다.
#[test]
fn report_counts_what_the_channel_rewrote() {
    let r = |s: &str, ch| mdwire::render_with(s, ch, mdwire::Options::default()).repairs;
    let gh = r(
        "약 ~40km, **「설정」**가 <!-- x --> H<sub>2</sub>\n\n* 하나\n- 둘\n\n| a |\n|---|\n| 1 |\n\n| b |\n| --- |\n| 2 |",
        Channel::GithubMarkdown,
    );
    assert_eq!(
        (gh.escaped_char, gh.tag_emphasis, gh.stripped_html, gh.rewritten_bullet, gh.rewritten_table, gh.converted_marker),
        (1, 1, 1, 1, 1, 0),
        "{gh:?}"
    );
    let slack = r("_기울임_ __굵게__ <https://a.com|링크>\n• 항목", Channel::SlackMarkdown);
    assert_eq!((slack.converted_marker, slack.rewritten_bullet), (3, 1), "{slack:?}");
    // 바꿀 것이 없으면 0 이다 — 이미 채널의 모양인 글.
    assert!(!r("**굵게** 와 `코드`\n\n- 하나", Channel::SlackMarkdown).changed());
    // `any()` 는 고친 것만 본다 — 이스케이프 하나로 "모델이 서식을 깼다"가 되지 않는다.
    let tilde = r("약 ~40km", Channel::GithubMarkdown);
    assert!(tilde.changed() && !tilde.any(), "{tilde:?}");
    // 줄 첫머리에서 벗긴 태그는 한 번씩 센다(두 번 세던 것).
    assert_eq!(r("<br>\n**x**", Channel::GithubMarkdown).stripped_html, 1);
    // `<url|텍스트>` 라벨의 이스케이프도 센다.
    assert_eq!(r("<https://a.com|l~x>", Channel::GithubMarkdown).escaped_char, 1);
    // 번호 목록 기호를 다시 쓴 것도 센다(`1)` → `1.`).
    assert_eq!(r("1) a\n2) b", Channel::SlackMarkdown).rewritten_bullet, 2);
}

/// **GFM 이 마커를 못 읽는 자리의 강조는 태그로 낸다**(실측 2026-09-30). 닫는 `**` 앞이
/// 구두점이고 뒤에 조사가 붙으면 GFM 은 닫지 않아 별표가 글자로 남고, 여럿이면 범위가 뒤집힌다.
#[test]
fn github_uses_tags_where_gfm_cannot_pair_markers() {
    let g = |s| one(s, Channel::GithubMarkdown);
    assert_eq!(g("**설정(config)**을 바꾼다"), "<strong>설정(config)</strong>을 바꾼다");
    assert_eq!(g("*\"인용\"*은 · ~~(취소)~~가"), "<em>\"인용\"</em>은 · <del>(취소)</del>가");
    assert_eq!(g("**`코드`**였다"), "<strong>`코드`</strong>였다");
    // GFM 이 읽는 자리는 마커 그대로다 — 원문을 되도록 그대로 둔다.
    assert_eq!(g("**마통**이 · **(중요)** 다 · 앞 **\"인용\"** 뒤"), "**마통**이 · **(중요)** 다 · 앞 **\"인용\"** 뒤");
    // 슬랙은 태그가 없어 못 읽히는 쪽 마커 안쪽에 U+2060 을 끼운다(실측 2026-10-01). 노션은 그대로 그린다.
    assert_eq!(one("**설정(config)**을", Channel::SlackMarkdown), "**설정(config)\u{2060}**을");
    assert_eq!(one("①**\"인용\" 끝**", Channel::SlackMarkdown), "①**\u{2060}\"인용\" 끝**");
    assert_eq!(one("**마통**이 · **(중요)** 다", Channel::SlackMarkdown), "**마통**이 · **(중요)** 다");
    assert_eq!(one("**설정(config)**을", Channel::NotionMarkdown), "**설정(config)**을");
    // 마커에 붙은 태그·주석이 벗겨지면 출력의 이웃이 바뀐다 — 그 자리는 태그로 낸다.
    assert_eq!(g("**x.**<font color=red>y</font> 끝"), "<strong>x.</strong>y 끝");
    assert_eq!(g("a<!-- c -->**(x** 끝"), "a<strong>(x</strong> 끝");
}

/// **GitHub 은 인라인 태그를 그리니 살린다.** LLM 이 `<sub>`·`<kbd>` 로 적은 뜻이 거기서는
/// 산다. **태그뿐인 줄만 벗긴다** — 줄 첫머리 여는 태그 뒤가 줄 끝까지 공백이면 GFM 이 HTML 블록을
/// 열어 뒤 줄의 마크다운이 글자로 보인다(실측). 봇 꼬리말 `<sub>모델 · 토큰</sub>` 처럼 태그 뒤에 글이
/// 오면 살린다(실사용 보고). 블록 태그(`div` `details`)와 새니타이저가 지우는 `font` 는 벗긴다.
#[test]
fn github_keeps_inline_tags_unless_the_line_is_only_tags() {
    let g = |s| one(s, Channel::GithubMarkdown);
    assert_eq!(g("H<sub>2</sub>O 와 <kbd>Ctrl</kbd> 줄<br>바꿈"), "H<sub>2</sub>O 와 <kbd>Ctrl</kbd> 줄<br>바꿈");
    assert_eq!(g("앞 <div>블록</div> <font color=red>빨강</font>"), "앞 블록 빨강");
    // 줄 첫머리라도 뒤에 글이 오면 살린다 — 봇 꼬리말.
    assert_eq!(g("본문\n\n<sub>모델 · 토큰</sub>"), "본문\n\n<sub>모델 · 토큰</sub>");
    assert_eq!(g("<sub>첫머리</sub> 뒤 <sub>둘</sub>"), "<sub>첫머리</sub> 뒤 <sub>둘</sub>");
    // 태그뿐인 줄은 벗기고, 짝인 닫는 태그도 벗긴다.
    assert_eq!(g("<sub>\n둘째 줄</sub> 끝"), "둘째 줄 끝");
    assert_eq!(g("앞\n<br>\n**굵게**"), "앞\n\n\n**굵게**");
    // 태그뿐인지는 출력으로 본다 — 뒤에 주석만 있으면 `<br>` 혼자 남아 HTML 블록이 된다.
    assert_eq!(g("<br><!-- x -->\n**굵게**"), "**굵게**");
    // `ins` 도 살린다. 블록 태그 `details` 는 벗긴다 — 줄 첫머리 `<details>` 는 HTML 블록을 열어 그
    // 안의 이스케이프가 글자로 보인다(내용은 남는다).
    assert_eq!(g("<ins>새</ins> 글"), "<ins>새</ins> 글");
    assert_eq!(g("<details><summary>약 ~40ms</summary>"), r"약 \~40ms");
    // 다른 채널은 그대로 벗긴다.
    assert_eq!(one("H<sub>2</sub>O", Channel::SlackMarkdown), "H2O");
}

/// **표 칸 안의 `<br>` 은 줄바꿈이 될 수 없다.** 칸 안에 줄바꿈이 들어가면 GFM 은 뒤를 새
/// 행으로 읽어 내용이 엉뚱한 열로 간다. GitHub 은 칸 안 `<br>` 을 그리니 그대로 둔다.
#[test]
fn br_inside_a_table_cell_keeps_the_row() {
    let input = "| a | 첫째<br>둘째 |\n|---|---|\n| 1 | 2 |";
    assert_eq!(one(input, Channel::GithubMarkdown), "| a | 첫째<br>둘째 |\n| --- | --- |\n| 1 | 2 |");
    assert_eq!(one(input, Channel::SlackMarkdown), "| a | 첫째 둘째 |\n| --- | --- |\n| 1 | 2 |");
    // 칸 밖은 여전히 줄바꿈이다(태그를 못 그리는 채널).
    assert_eq!(one("줄<br>바꿈", Channel::SlackMarkdown), "줄\n바꿈");
}

/// **`** 띄운 굵게 **` 는 글자다.** 열 수도 닫을 수도 없는 마커 둘이라 CommonMark 도
/// 슬랙도 글자로 둔다. 전에는 닫는 쪽만 삼켜 `** 띄운 굵게  는` 이 됐다 — 내용 손실이다.
#[test]
fn spaced_bold_markers_stay_as_text() {
    assert_eq!(one("** 배포 ** 는 금지", Channel::SlackMarkdown), "** 배포 ** 는 금지");
    assert_eq!(one("** 배포 ** 는 금지", Channel::TelegramHtml), "** 배포 ** 는 금지");
    // 앞이 글자인 닫기는 여전히 닫는다 — `**굵게 **` 는 관대하게 굵게다.
    assert_eq!(one("**굵게 ** 끝", Channel::TelegramHtml), "<b>굵게 </b> 끝");
}

/// **슬랙 조각도 스팬 한가운데서 갈리지 않는다.** 12,000자 분할이 `` `main → main` ``
/// 의 공백에 떨어지면 두 메시지 다 백틱이 홀로 남았다 — 텔레그램 태그와 같은 규칙으로
/// 끊는 자리에서 닫고 다음 조각에서 다시 연다.
#[test]
fn slack_parts_close_and_reopen_spans() {
    let filler = "가나다 ".repeat(2997); // 11,988자 — 그 뒤의 공백은 스팬 안에만 있다
    let tail = "가".repeat(40);
    for span in [format!("`main → {tail}`"), format!("**굵은 말 {tail}**"), format!("~~취소 {tail}~~")] {
        let input = format!("{filler}{span}\n");
        let parts = render(&input, Channel::SlackMarkdown);
        assert!(parts.len() >= 2, "{span}: 나뉘어야 한다");
        for p in &parts {
            assert!(p.chars().count() <= Channel::SlackMarkdown.limit());
            assert_eq!(p.matches('`').count() % 2, 0, "백틱이 홀로 남았다: …{}", &p[p.len().saturating_sub(30)..]);
            assert_eq!(p.matches("**").count() % 2, 0, "`**` 가 홀로 남았다: …{}", &p[p.len().saturating_sub(30)..]);
            assert_eq!(p.matches("~~").count() % 2, 0, "`~~` 가 홀로 남았다: …{}", &p[p.len().saturating_sub(30)..]);
            // 닫는 마커 앞과 여는 마커 뒤에 공백이 오면 마커가 아니라 글자다.
            for m in ["**", "~~", "`"] {
                assert!(!p.ends_with(&format!(" {m}")), "공백 뒤에 닫았다: …{}", &p[p.len().saturating_sub(30)..]);
                assert!(!p.starts_with(&format!("{m} ")), "공백 앞에서 열었다: {}…", &p[..p.len().min(30)]);
            }
        }
    }
}

/// **공백 없는 긴 강조를 글자로 끊어도 조각이 한도를 지킨다.** 닫는 마커가 덩어리 끝에
/// 있으면 예산을 "열린 것 없음"으로 재서, 한도까지 채운 뒤 닫는 마커를 붙여 넘겼다.
#[test]
fn a_long_space_free_span_is_cut_within_the_limit() {
    // 가장 큰 한도보다 길어야 모든 채널이 나눈다. 한도가 없는 채널(html)은 나누지 않으니 뺀다.
    let splits = |c: &Channel| c.limit() < usize::MAX;
    let longest = Channel::all().iter().filter(|c| splits(c)).map(|c| c.limit()).max().expect("채널이 있다");
    let input = format!("**{}**", "a".repeat(longest + longest / 2));
    for channel in Channel::all().into_iter().filter(splits) {
        let parts = render(&input, channel);
        assert!(parts.len() > 1, "{}: 나뉘어야 한다", channel.name());
        for p in &parts {
            let n = p.chars().count();
            assert!(n <= channel.limit(), "{}: {n}자 조각 — 한도 {}", channel.name(), channel.limit());
        }
    }
}

// ── 고친 것 ─────────────────────────────────────────────────────────

/// **정규화가 고친 것을 센다.** 모델이 얼마나 자주 서식을 깨는지 재는 데 쓴다.
#[test]
fn repairs_count_what_the_normalizer_fixed() {
    let out = mdwire::render_with("**영향 범위\n```ts\nconst a = `b;\n", Channel::TelegramHtml, mdwire::Options::default());
    assert_eq!(out.repairs.closed_emphasis, 1, "{:?}", out.repairs);
    assert_eq!(out.repairs.closed_fence, 1, "{:?}", out.repairs);

    let out = mdwire::render_with("앞 ` 뒤 **굵게** 와 꼬리**", Channel::TelegramHtml, mdwire::Options::default());
    assert_eq!(out.repairs.reverted_code_span, 1, "{:?}", out.repairs);
    assert_eq!(out.repairs.dropped_marker, 1, "{:?}", out.repairs);

    // 멀쩡한 입력은 아무것도 안 고친다.
    let out = mdwire::render_with("**굵게** 와 `코드`\n```\n펜스\n```", Channel::SlackMarkdown, mdwire::Options::default());
    assert!(!out.repairs.any(), "{:?}", out.repairs);

    // 표 셀에서 고친 것도 센다 — 셀을 그리는 인라인이 따로 돌아도 문서의 것이다.
    for ch in [Channel::SlackMarkdown, Channel::TelegramHtml] {
        let out = mdwire::render_with("| a |\n|---|\n| **x |", ch, mdwire::Options::default());
        assert_eq!(out.repairs.closed_emphasis, 1, "{ch:?} {:?}", out.repairs);
    }
}

/// 스트리밍도 같은 수를 센다 — 조각 크기와 무관하게.
#[test]
fn streamer_counts_the_same_repairs() {
    let input = "**영향 범위\n다음 줄\n\n앞 ` 뒤 꼬리**\n```ts\nconst a = 1;";
    let batch = mdwire::render_with(input, Channel::TelegramHtml, mdwire::Options::default());
    for size in [1usize, 3, 64] {
        let mut s = Streamer::new(Channel::TelegramHtml);
        let mut got = String::new();
        let chars: Vec<char> = input.chars().collect();
        for chunk in chars.chunks(size) {
            s.push_into(&chunk.iter().collect::<String>(), &mut got);
        }
        s.finish_into(&mut got);
        assert_eq!(got, batch.parts.join(""), "조각 {size}");
        assert_eq!(s.repairs(), batch.repairs, "조각 {size}");
    }
}

/// **붙든 구문을 이어서 훑어도 답은 같아야 한다.** 안 닫힌 `[`·`<!--` 는 훑던 자리를 기억해 두고
/// 새 꼬리만 보는데, 그 기억이 조각 경계·중첩·뒤늦은 닫힘에서 틀리면 스트리밍이 완성본과
/// 갈린다. 모든 조각 크기로 흘려 본다.
#[test]
fn resumed_hold_scans_agree_with_batch() {
    let inputs = [
        "앞 [긴 텍스트 [중첩] 계속](https://x.io/a) 뒤",
        "[a](1.[b](url) 끝",
        "[텍스트] 링크 아님, 그리고 [둘](u)",
        "앞 <!-- 주석 - -- 아직 --> 뒤 **굵게**",
        "<!-- 안 닫힌 주석 [x](y) 끝까지",
        "[안 닫힌 링크 <!-- 주석 --> 끝까지",
        "**굵게 [링크](u) <!--c--> 끝**",
    ];
    for input in inputs {
        for channel in [Channel::TelegramHtml, Channel::SlackMarkdown] {
            let batch = render(input, channel).join("");
            let chars: Vec<char> = input.chars().collect();
            for size in 1..=chars.len() {
                let mut s = Streamer::new(channel);
                let mut got = String::new();
                for chunk in chars.chunks(size) {
                    s.push_into(&chunk.iter().collect::<String>(), &mut got);
                }
                s.finish_into(&mut got);
                assert_eq!(got, batch, "{input:?} · {} · 조각 {size}", channel.name());
            }
        }
    }
}

// ── 브라우저 HTML ─────────────────────────────────────────────────────

/// **블록까지 태그로 그린다.** 헤딩·문단·목록·인용·코드블록·표·구분선. 드로어가 줄마다
/// 정규식으로 그리던 것에서 실측으로 깨지던 것들(줄 넘는 굵게, 헤딩·목록이 글자로 보임)이다.
#[test]
fn html_renders_blocks_as_tags() {
    let h = |s| one(s, Channel::Html);
    assert_eq!(h("## 제목"), "<h2>제목</h2>");
    assert_eq!(h("문단 **굵게\n이어짐** 끝"), "<p>문단 <strong>굵게<br>\n이어짐</strong> 끝</p>");
    assert_eq!(h("> 인용\n> 둘째"), "<blockquote>인용<br>\n둘째</blockquote>");
    assert_eq!(h("```ts\na < b\n```"), "<pre><code class=\"language-ts\">a &lt; b</code></pre>");
    assert_eq!(h("---"), "<hr>");
    assert_eq!(
        h("| a | b |\n|---|--:|\n| **x** | 1 |"),
        "<table>\n<thead><tr><th>a</th><th style=\"text-align:right\">b</th></tr></thead>\n\
         <tbody><tr><td><strong>x</strong></td><td style=\"text-align:right\">1</td></tr></tbody>\n</table>"
    );
}

/// **목록은 들여쓰기로 중첩을 연다.** 더 깊으면 항목 안에 새 목록, 얕으면 그만큼 닫는다.
/// 1 이 아닌 번호로 시작하는 번호 목록은 번호를 잇는다.
#[test]
fn html_nests_lists_by_indent() {
    let h = |s| one(s, Channel::Html);
    assert_eq!(
        h("- 하나\n  - 둘\n    1. 셋\n- 넷"),
        "<ul><li>하나\n<ul><li>둘\n<ol><li>셋\n</li></ol></li></ul></li><li>넷</li></ul>"
    );
    assert_eq!(h("3. 삼\n4. 사"), "<ol start=\"3\"><li>삼\n</li><li>사</li></ol>");
    // 같은 깊이에서 종류가 바뀌면 목록을 갈아 낀다.
    assert_eq!(h("- 가\n1. 나"), "<ul><li>가\n</li></ul><ol><li>나</li></ol>");
    // 빈 줄로 띄운 목록(loose list)도 한 목록이다 — 빈 줄 뒤 들여쓴 항목이 밖으로 빠지면 안 된다.
    let loose = h("- a\n\n  - b\n\n- c");
    assert!(loose.starts_with("<ul><li>a") && loose.contains("<ul><li>b") && loose.ends_with("</li><li>c</li></ul>"), "{loose}");
    assert_eq!(loose.matches("<ul>").count(), 2, "{loose}");
    // 목록 뒤에 빈 줄을 두고 문단이 오면 목록은 거기서 닫힌다.
    assert_eq!(h("- a\n\n문단"), "<ul><li>a</li></ul>\n\n<p>문단</p>");
}

/// **`innerHTML` 로 들어가는 출력이다.** 글자는 이스케이프하고, `javascript:` 링크는 글로
/// 떨어뜨리고, 원문 태그는 속성을 버린 이름만 살린다. 짝이 안 맞는 원문 태그는 강조와 같은
/// 스택에서 맞춘다 — 퍼즈가 `<sub>` 만 열고 끝난 입력에서 잡았다.
#[test]
fn html_output_is_safe_for_inner_html() {
    let h = |s| one(s, Channel::Html);
    assert_eq!(h("1 < 2 & `a<b>`"), "<p>1 &lt; 2 &amp; <code>a&lt;b&gt;</code></p>");
    assert_eq!(h("[나쁨](javascript:alert) [좋음](https://a.com)"), "<p>나쁨 (javascript:alert) <a href=\"https://a.com\">좋음</a></p>");
    assert_eq!(h("[메일](MAILTO:a@b.c)"), "<p><a href=\"MAILTO:a@b.c\">메일</a></p>");
    assert_eq!(h("H<sub onclick=\"x()\">2</sub>O"), "<p>H<sub>2</sub>O</p>");
    assert_eq!(h("<div>블록</div> <script>x</script>"), "<p>블록 &lt;script&gt;x&lt;/script&gt;</p>");
    assert_eq!(h("**a<sub>b**c</sub>"), "<p><strong>a<sub>b</sub></strong>c</p>");
    assert_eq!(h("<sub>안 닫힘 뒤 </b> 끝"), "<p><sub>안 닫힘 뒤  끝</sub></p>");
    // 줄을 넘은 코드 스팬이 안 닫혀 글자로 되돌아가도 줄바꿈 `<br>` 은 남는다.
    assert_eq!(h("앞 `a\nb 뒤"), "<p>앞 `a<br>\nb 뒤</p>");
    assert_eq!(h("- 앞 `a\n  b 뒤"), "<ul><li>앞 `a<br>\n  b 뒤</li></ul>");
    // 코드펜스 info 는 속성값이라 `"` 까지 escape 한다 — 속성 주입을 막는다. 언어는 첫
    // 단어뿐이라 공백 없이 붙인 주입으로 잰다.
    assert_eq!(
        h("```x\"onmouseover=\"alert(1)\ncode\n```"),
        "<pre><code class=\"language-x&quot;onmouseover=&quot;alert(1)\">code</code></pre>"
    );
}

/// **스트리밍 누적본에 `close_open` 을 붙이면 언제나 균형 잡힌 HTML 이다.** 브라우저에
/// 토큰이 오는 대로 `innerHTML` 을 갈아 끼우는 쓰임새의 계약이다. 한 글자씩 흘리며 매번 잰다.
#[test]
fn html_streaming_snapshot_is_always_balanced() {
    let input = "## 제목\n\n문단 **굵게** 와 `코드`\n\n- 하나\n  - 둘 <sub>x</sub>\n- 셋\n\n> 인용\n\n```\nfence\n```\n| a | b |\n|---|---|\n| 1 | 2 |\n";
    let mut s = mdwire::Streamer::new(Channel::Html);
    let mut acc = String::new();
    for ch in input.chars() {
        s.push_into(ch.encode_utf8(&mut [0; 4]), &mut acc);
        let mut snap = acc.clone();
        s.close_open(&mut snap);
        assert!(balanced_html(&snap), "균형이 깨진 스냅숏: {snap}");
    }
    s.finish_into(&mut acc);
    assert_eq!(acc, render(input, Channel::Html).join(""));
    assert!(balanced_html(&acc));
}

fn balanced_html(s: &str) -> bool {
    let mut stack: Vec<String> = Vec::new();
    let mut rest = s;
    while let Some(at) = rest.find('<') {
        let Some(end) = rest[at..].find('>') else { return false };
        let tag = &rest[at + 1..at + end];
        rest = &rest[at + end + 1..];
        let name: String = tag.trim_start_matches('/').chars().take_while(|c| c.is_ascii_alphanumeric()).collect();
        if matches!(name.as_str(), "br" | "hr") {
            continue;
        }
        if tag.starts_with('/') {
            if stack.pop().as_deref() != Some(name.as_str()) {
                return false;
            }
        } else {
            stack.push(name);
        }
    }
    stack.is_empty()
}

/// **살려 둔 원문 태그도 조각 경계에서 닫고 다시 연다**(GitHub 65,536 분할). 안 그러면 앞
/// 조각은 `<sub>` 가 열린 채 끝나고 뒤 조각은 `</sub>` 만 들고 시작한다(리뷰에서 나왔다).
/// 줄 첫머리에서 벗긴 태그는 이름이 맞는 닫는 태그만 벗기고, 표 칸 첫머리는 줄 첫머리가 아니다.
#[test]
fn github_kept_tags_survive_splits_and_match_by_name() {
    let input = format!("x <sub>{}</sub> 끝", "가나 ".repeat(30_000));
    let parts = render(&input, Channel::GithubMarkdown);
    assert!(parts.len() > 1);
    for p in &parts {
        assert_eq!(p.matches("<sub>").count(), p.matches("</sub>").count(), "조각 안에서 짝이 안 맞는다");
    }
    let g = |s| one(s, Channel::GithubMarkdown);
    assert_eq!(g("<sub>foo <kbd>x</kbd></sub> 뒤"), "<sub>foo <kbd>x</kbd></sub> 뒤");
    assert_eq!(g("<sub>\nfoo <kbd>x</kbd></sub> 뒤"), "foo <kbd>x</kbd> 뒤");
    assert_eq!(g("| <sub>h</sub> | b |\n|---|---|\n| 1 | 2 |"), "| <sub>h</sub> | b |\n| --- | --- |\n| 1 | 2 |");
    assert_eq!(g("앞 <SPAN style=\"x\">가</SPAN>"), "앞 <span>가</span>");
}

/// **한도는 호출자가 정한다.** plain 을 텔레그램 폴백으로 보내면 12,000 이 아니라 4096 이어야
/// 한다 — 12,000 으로 나눈 7,153자 조각이 400 을 받았다(실측). 텔레그램 링크를 글로 내리는
/// 판정도 그 한도를 따른다.
#[test]
fn caller_limit_overrides_the_channel_limit() {
    let long = "가나다 ".repeat(3000);
    assert_eq!(render(&long, Channel::Plain).len(), 1);
    let opts = mdwire::Options { limit: Some(4096), ..Default::default() };
    let parts = mdwire::render_with(&long, Channel::Plain, opts).parts;
    assert!(parts.len() > 1 && parts.iter().all(|p| p.chars().count() <= 4096));
    // 한도보다 긴 주소는 링크로 내지 않는다 — 채널 한도가 아니라 호출자 한도 기준이다.
    let url = format!("https://a.com/{}", "x".repeat(300));
    let input = format!("[문서]({url})");
    let opts = mdwire::Options { limit: Some(mdwire::MIN_LIMIT), ..Default::default() };
    let out = mdwire::render_with(&input, Channel::TelegramHtml, opts).parts.join("");
    assert!(!out.contains("<a href"), "한도 256 에 300자 주소 링크: {out}");
}

/// **한도가 마크업보다 작아도 태그 한가운데서 가르지 않는다.** 한도 1 로 텔레그램 `**x**` 를 나누면
/// `<` · `b` · `></b>` 가 됐다(리뷰에서 나왔다) — 최소 한도([`mdwire::MIN_LIMIT`])로 올린다. 브라우저
/// 채널은 분할기가 블록 태그를 여닫지 않아 한도를 보지 않는다.
#[test]
fn tiny_limits_are_raised_and_html_never_splits() {
    let tiny = mdwire::Options { limit: Some(1), ..Default::default() };
    assert_eq!(mdwire::render_with("**x**", Channel::TelegramHtml, tiny.clone()).parts, vec!["<b>x</b>"]);
    assert_eq!(mdwire::render_with("abcdefghijklmnop", Channel::Html, tiny).parts, vec!["<p>abcdefghijklmnop</p>"]);
    let long = "가나다 ".repeat(300);
    let parts = mdwire::render_with(&long, Channel::Plain, mdwire::Options { limit: Some(10), ..Default::default() }).parts;
    assert!(parts.len() > 1 && parts.iter().all(|p| p.chars().count() <= mdwire::MIN_LIMIT));
}

/// **브라우저 채널의 정책은 호출자가 정한다** — 줄바꿈, 이미지, 스킴. 기본값이 가장
/// 보수적이다: `<br>`, 이미지는 링크로만(누르기 전엔 아무것도 안 불러온다), `http(s)`·`mailto`.
#[test]
fn html_policy_options() {
    use mdwire::{HtmlOptions, Images, LineBreaks, Options};
    let input = "첫 줄\n둘째 ![고양이](https://a.com/c.png) [전화](tel:010) ![나쁨](javascript:x)";
    let h = |html: HtmlOptions| {
        mdwire::render_with(input, Channel::Html, Options { html, ..Default::default() }).parts.join("")
    };
    assert_eq!(
        h(HtmlOptions::default()),
        "<p>첫 줄<br>\n둘째 <a href=\"https://a.com/c.png\">고양이</a> 전화 (tel:010) 나쁨 (javascript:x)</p>"
    );
    assert!(h(HtmlOptions { line_breaks: LineBreaks::Space, ..Default::default() }).starts_with("<p>첫 줄\n둘째"));
    // 불러오기로 해도 허용 스킴이 아닌 주소는 이미지가 되지 않는다.
    let load = h(HtmlOptions { images: Images::Load, ..Default::default() });
    assert!(load.contains("<img src=\"https://a.com/c.png\" alt=\"고양이\">") && load.contains("나쁨 (javascript:x)"));
    // 목록을 주면 그것만 받는다 — 기본값에 더하는 것이 아니다.
    let tel = h(HtmlOptions { schemes: Some(vec!["https".into(), "TEL".into()]), ..Default::default() });
    assert!(tel.contains("<a href=\"tel:010\">전화</a>"));
    let only_tel = h(HtmlOptions { schemes: Some(vec!["tel".into()]), ..Default::default() });
    assert!(only_tel.contains("고양이 (https://a.com/c.png)"));
    // 다른 채널의 이미지 — 텔레그램은 링크, GitHub 은 이미지 구문 그대로.
    assert_eq!(one("![고양이](https://a.com/c.png)", Channel::TelegramHtml), "<a href=\"https://a.com/c.png\">고양이</a>");
    assert_eq!(one("![고양이](https://a.com/c.png)", Channel::GithubMarkdown), "![고양이](https://a.com/c.png)");
    // 스트리밍 — 조각 끝의 `!` 는 다음 글자가 `[` 인지 볼 때까지 붙든다.
    let mut s = mdwire::Streamer::new(Channel::Html);
    let mut acc = String::new();
    for piece in ["사진 !", "[고양이](https://a.com/c.png) 끝!"] {
        s.push_into(piece, &mut acc);
    }
    s.finish_into(&mut acc);
    assert_eq!(acc, render("사진 ![고양이](https://a.com/c.png) 끝!", Channel::Html).join(""));
}

/// **미리보기는 붙든 것을 먼저 그린다.** 확정분은 여는 `**` 앞에서 멈추지만, 미리보기는 닫아서
/// 보여 준다. 표는 지금까지 온 행으로, 코드 스팬은 닫는 백틱을 넣어서.
#[test]
fn preview_draws_what_push_holds() {
    fn snap(channel: Channel, input: &str) -> (String, String) {
        let mut s = Streamer::new(channel);
        let mut acc = String::new();
        s.push_into(input, &mut acc);
        let tail = s.preview().to_string();
        (acc, tail)
    }
    assert_eq!(snap(Channel::TelegramHtml, "앞말 **굵"), ("앞말 ".into(), "<b>굵</b>".into()));
    assert_eq!(snap(Channel::TelegramHtml, "앞 `코드"), ("앞 ".into(), "<code>코드</code>".into()));
    // 닫는 백틱이 조각 끝에 붙들려 있어도, 줄을 넘어 열려 있어도 코드로 닫는다 — 닫는 백틱을
    // 입력으로 흘려 넣던 때는 `` ` `` 두 개가 합쳐지고, 새 줄 첫머리의 펜스로 읽혔다(자체 리뷰).
    for (channel, input) in [
        (Channel::TelegramHtml, "앞 `코드`"),
        (Channel::TelegramHtml, "앞 `코드` "),
        (Channel::Html, "> a ```b\n"),
        (Channel::Html, "> a `b\n"),
        (Channel::Html, "- a `b\n"),
    ] {
        let (acc, tail) = snap(channel, input);
        let got = acc + &tail;
        assert!(!got.contains('`') && !got.contains("<pre>"), "{input:?} → {got:?}");
    }
    let (acc, tail) = snap(Channel::Html, "| a | b |\n|---|---|\n| 1 | 2 |\n| 3");
    assert!(acc.is_empty() && tail.starts_with("<table>") && tail.contains("<td>1</td>"), "{tail}");
    // 미리보기는 상태를 바꾸지 않는다 — 이어서 흘린 결과가 일괄 렌더와 같다.
    let mut s = Streamer::new(Channel::TelegramHtml);
    let mut acc = String::new();
    for c in ["앞 **굵", "게** `코", "드` 끝"] {
        s.push_into(c, &mut acc);
        let _ = s.preview();
    }
    s.finish_into(&mut acc);
    assert_eq!(acc, render("앞 **굵게** `코드` 끝", Channel::TelegramHtml).concat());
}

/// **`revised` — 마지막 화면을 다시 그려야 하는가.** 소비자(텔레그램 편집)가 정할 수 있게
/// 마지막 미리보기와 완성본이 다른지만 알려 준다.
#[test]
fn revised_tells_whether_the_last_preview_was_final() {
    let run = |chunks: &[&str], preview_last: bool| {
        let mut s = Streamer::new(Channel::TelegramHtml);
        let mut acc = String::new();
        for c in chunks {
            s.push_into(c, &mut acc);
        }
        if preview_last {
            let _ = s.preview();
        }
        s.finish_into(&mut acc);
        s.revised()
    };
    assert!(!run(&["앞 **굵게** 끝"], true), "마지막 미리보기가 곧 완성본");
    assert!(run(&["앞 `안 닫힌 코드"], true), "미리보기는 코드로, 완성본은 글자로");
    assert!(run(&["앞 **굵게** 끝"], false), "미리보기를 안 했으면 다시 그린다");
    let mut s = Streamer::new(Channel::TelegramHtml);
    let mut acc = String::new();
    s.push_into("앞", &mut acc);
    let _ = s.preview();
    s.push_into(" 뒤", &mut acc);
    s.finish_into(&mut acc);
    assert!(s.revised(), "미리보기 뒤에 조각이 더 왔다");
    assert_eq!(s.preview(), "", "끝난 뒤에는 더 그릴 꼬리가 없다");
    let mut s = Streamer::new(Channel::TelegramHtml);
    s.push_into("앞 **굵", &mut acc);
    s.finish_into(&mut acc);
    assert_eq!(s.preview(), "", "미리보기 없이 끝났어도 마찬가지");
}