apex-ruby 1.0.18 → 1.0.20

data/ext/apex_ext/apex_src/tests/test_extensions.c

@@ -4,11 +4,79 @@
 
 #include "test_helpers.h"
 #include "apex/apex.h"
+#include "../src/html_renderer.h"
 #include "../src/extensions/advanced_footnotes.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
+static char *replace_first_substring(const char *text,
+                                     const char *needle,
+                                     const char *replacement) {
+    const char *pos = strstr(text, needle);
+    if (!pos) {
+        return NULL;
+    }
+
+    size_t prefix_len = (size_t)(pos - text);
+    size_t needle_len = strlen(needle);
+    size_t replacement_len = strlen(replacement);
+    size_t suffix_len = strlen(pos + needle_len);
+    char *result = malloc(prefix_len + replacement_len + suffix_len + 1);
+    if (!result) {
+        return NULL;
+    }
+
+    memcpy(result, text, prefix_len);
+    memcpy(result + prefix_len, replacement, replacement_len);
+    memcpy(result + prefix_len + replacement_len, pos + needle_len, suffix_len + 1);
+    return result;
+}
+
+static char *include_preparse_plugin_callback(const char *text,
+                                              __attribute__((unused)) const char *id_plugin,
+                                              apex_plugin_phase_mask phase,
+                                              __attribute__((unused)) const apex_options *options) {
+    if (!(phase & APEX_PLUGIN_PHASE_PRE_PARSE) || !text) {
+        return NULL;
+    }
+
+    char *current = strdup(text);
+    if (!current) {
+        return NULL;
+    }
+
+    bool changed = false;
+    char *next = replace_first_substring(current, "Included Content", "Plugin Included Content");
+    if (next) {
+        free(current);
+        current = next;
+        changed = true;
+    }
+
+    next = replace_first_substring(current, "## Section 2", "## Plugin Section 2");
+    if (next) {
+        free(current);
+        current = next;
+        changed = true;
+    }
+
+    if (!changed) {
+        free(current);
+        return NULL;
+    }
+
+    return current;
+}
+
+static void include_preparse_plugin_register(apex_plugin_manager *manager,
+                                             __attribute__((unused)) const apex_options *options) {
+    apex_plugin_register(manager,
+                         "include-preparse-plugin",
+                         APEX_PLUGIN_PHASE_PRE_PARSE,
+                         include_preparse_plugin_callback);
+}
+
 void test_math(void) {
     int suite_failures = suite_start();
     print_suite_title("Math Support Tests", false, true);
@@ -172,10 +240,331 @@ void test_processor_modes(void) {
     assert_contains(html, "<h1", "Unified mode works");
     apex_free_string(html);
 
+    /* Test Quarto mode */
+    apex_options quarto_opts = apex_options_for_mode(APEX_MODE_QUARTO);
+    html = apex_markdown_to_html(markdown, strlen(markdown), &quarto_opts);
+    assert_contains(html, "<h1", "Quarto mode works");
+    test_result(quarto_opts.enable_quarto_callouts == true, "Quarto mode enables quarto callouts by default");
+    test_result(quarto_opts.enable_quarto_extensions == true, "Quarto mode enables quarto extensions by default");
+    test_result(quarto_opts.enable_quarto_diagrams == true, "Quarto mode enables quarto diagrams by default");
+    test_result(quarto_opts.enable_quarto_shortcodes == true, "Quarto mode enables quarto shortcodes by default");
+    test_result(quarto_opts.enable_quarto_xrefs == true, "Quarto mode enables quarto xrefs by default");
+    test_result(quarto_opts.enable_quarto_strict_lists == false, "Quarto mode keeps strict lists off by default");
+    apex_free_string(html);
+
     bool had_failures = suite_end(suite_failures);
     print_suite_title("Processor Modes Tests", had_failures, false);
 }
 
+void test_quarto_mode(void) {
+    int suite_failures = suite_start();
+    print_suite_title("Quarto Mode Tests", false, true);
+
+    apex_options opts = apex_options_for_mode(APEX_MODE_QUARTO);
+    char *html;
+
+    const char *callout =
+        "::: {.callout-warning}\n"
+        "Warning body.\n"
+        "::: ";
+    html = apex_markdown_to_html(callout, strlen(callout), &opts);
+    assert_contains(html, "class=\"callout", "Quarto mode renders callout blocks");
+    assert_contains(html, "Warning body", "Quarto callout body preserved");
+    apex_free_string(html);
+
+    const char *fig_alt = "![Caption](elephant.png){fig-alt=\"Alt text\"}";
+    html = apex_markdown_to_html(fig_alt, strlen(fig_alt), &opts);
+    assert_contains(html, "<figure>", "fig-alt image wrapped in figure");
+    assert_contains(html, "<figcaption>Caption</figcaption>", "fig-alt uses markdown alt as caption");
+    assert_contains(html, "alt=\"Alt text\"", "fig-alt maps to img alt attribute");
+    assert_not_contains(html, "fig-alt=", "fig-alt attribute stripped from output");
+    apex_free_string(html);
+
+    /* Direct convert test: fig-alt rewrites img alt for accessibility */
+    {
+        const char *in = "<p><img src=\"elephant.png\" alt=\"Caption\" fig-alt=\"Alt text\" /></p>";
+        char *out = apex_convert_image_captions(in, true, false);
+        assert_contains(out, "alt=\"Alt text\"", "fig-alt maps to img alt attribute (direct convert)");
+        assert_contains(out, "<figcaption>Caption</figcaption>", "fig-alt caption from markdown alt (direct convert)");
+        free(out);
+    }
+
+    const char *div_block = "::: {.sidebar}\nSidebar content.\n:::";
+    html = apex_markdown_to_html(div_block, strlen(div_block), &opts);
+    assert_contains(html, "class=\"sidebar\"", "Quarto mode renders fenced divs");
+    apex_free_string(html);
+
+    const char *raw_html_block =
+        "Before\n\n"
+        "```{=html}\n"
+        "<strong>raw</strong>\n"
+        "```\n\n"
+        "After";
+    html = apex_markdown_to_html(raw_html_block, strlen(raw_html_block), &opts);
+    assert_contains(html, "<strong>raw</strong>", "raw {=html} block passthrough");
+    assert_not_contains(html, "**raw**", "raw {=html} block not markdown-processed");
+    assert_not_contains(html, "<code", "raw {=html} block not wrapped in code");
+    apex_free_string(html);
+
+    const char *raw_latex_block =
+        "```{=latex}\n"
+        "\\textbf{Bold}\n"
+        "```";
+    html = apex_markdown_to_html(raw_latex_block, strlen(raw_latex_block), &opts);
+    assert_contains(html, "<!-- raw format=latex -->", "raw {=latex} block wrapped in comment");
+    assert_contains(html, "\\textbf{Bold}", "raw {=latex} body preserved in comment");
+    assert_not_contains(html, "<code", "raw {=latex} block not wrapped in code");
+    apex_free_string(html);
+
+    const char *raw_html_inline = "Text `<em>inline</em>`{=html} end.";
+    html = apex_markdown_to_html(raw_html_inline, strlen(raw_html_inline), &opts);
+    assert_contains(html, "<em>inline</em>", "inline {=html} passthrough");
+    assert_not_contains(html, "`{=html}`", "inline {=html} marker stripped");
+    apex_free_string(html);
+
+    /* Unified mode without quarto extensions leaves {=html} fences intact */
+    apex_options unified_opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+    unified_opts.enable_quarto_extensions = false;
+    html = apex_markdown_to_html("```{=html}\n<b>x</b>\n```", 18, &unified_opts);
+    assert_contains(html, "<code", "non-quarto mode keeps {=html} as code fence");
+    apex_free_string(html);
+
+    const char *example_lists =
+        "(@)  My first example will be numbered (1).\n"
+        "(@)  My second example will be numbered (2).\n";
+    html = apex_markdown_to_html(example_lists, strlen(example_lists), &opts);
+    assert_contains(html, "<ol>", "example list (@) produces ordered list");
+    assert_contains(html, "My first example", "example list first item");
+    assert_contains(html, "My second example", "example list second item");
+    assert_not_contains(html, "(@)", "example list marker stripped");
+    apex_free_string(html);
+
+    const char *example_lists_break =
+        "(@)  My first example will be numbered (1).\n"
+        "(@)  My second example will be numbered (2).\n"
+        "\n"
+        "Explanation of examples.\n"
+        "\n"
+        "(@)  My third example will be numbered (3).\n";
+    html = apex_markdown_to_html(example_lists_break, strlen(example_lists_break), &opts);
+    assert_contains(html, "Explanation of examples", "example list keeps interruption text");
+    assert_contains(html, "My third example", "example list third item after break");
+    assert_contains(html, "start=\"3\"", "example list continues numbering after interruption");
+    assert_not_contains(html, "(@)", "example list break strips marker");
+    apex_free_string(html);
+
+    const char *example_lists_labeled =
+        "(@good)  This is a good example.\n";
+    html = apex_markdown_to_html(example_lists_labeled, strlen(example_lists_labeled), &opts);
+    assert_contains(html, "This is a good example", "labeled example list item content");
+    assert_not_contains(html, "(@good)", "labeled example list marker stripped");
+    apex_free_string(html);
+
+    const char *roman_list =
+        "i) First\n"
+        "ii) Second\n"
+        "iii) Third\n";
+    html = apex_markdown_to_html(roman_list, strlen(roman_list), &opts);
+    assert_contains(html, "list-style-type: lower-roman", "roman list lower-roman style");
+    assert_contains(html, "First", "roman list first item");
+    assert_contains(html, "Second", "roman list second item");
+    assert_not_contains(html, "<!-- apex-alpha-list-", "roman list marker comment stripped");
+    apex_free_string(html);
+
+    const char *line_block =
+        "| Line one\n"
+        "|   preserved spaces\n"
+        "| Line three\n";
+    html = apex_markdown_to_html(line_block, strlen(line_block), &opts);
+    assert_contains(html, "class=\"line-block\"", "line block wrapper");
+    assert_contains(html, "class=\"line\">Line one", "line block first line");
+    assert_contains(html, "class=\"line\">  preserved spaces", "line block preserves inner spaces");
+    assert_contains(html, "class=\"line\">Line three", "line block third line");
+    apex_free_string(html);
+
+    const char *code_fence_attrs =
+        "```{.python filename=\"run.py\"}\n"
+        "print(\"hello\")\n"
+        "```\n";
+    html = apex_markdown_to_html(code_fence_attrs, strlen(code_fence_attrs), &opts);
+    assert_contains(html, "data-filename=\"run.py\"", "code fence filename attribute on pre");
+    assert_contains(html, "print", "code fence body preserved");
+    assert_not_contains(html, "{.python", "code fence braced info string normalized");
+    assert_not_contains(html, "apex-code-fence-attrs", "code fence marker comment stripped");
+    apex_free_string(html);
+
+    const char *code_fence_linenos =
+        "```{.python linenos=true}\n"
+        "print(\"hi\")\n"
+        "```\n";
+    html = apex_markdown_to_html(code_fence_linenos, strlen(code_fence_linenos), &opts);
+    assert_contains(html, "data-linenos=\"true\"", "code fence linenos attribute on pre");
+    apex_free_string(html);
+
+    const char *mermaid_fence =
+        "```{mermaid}\n"
+        "flowchart LR\n"
+        "  A --> B\n"
+        "```\n";
+    html = apex_markdown_to_html(mermaid_fence, strlen(mermaid_fence), &opts);
+    assert_contains(html, "<pre class=\"mermaid\">", "mermaid fence renders pre.mermaid");
+    assert_contains(html, "flowchart LR", "mermaid fence body preserved");
+    assert_contains(html, "A --> B", "mermaid fence diagram content preserved");
+    assert_not_contains(html, "{mermaid}", "mermaid fence marker stripped");
+    assert_not_contains(html, "<code", "mermaid fence not wrapped in code");
+    apex_free_string(html);
+
+    const char *dot_fence =
+        "```{dot}\n"
+        "digraph { A -> B; }\n"
+        "```\n";
+    html = apex_markdown_to_html(dot_fence, strlen(dot_fence), &opts);
+    assert_contains(html, "<pre class=\"graphviz\">", "dot fence renders pre.graphviz");
+    assert_contains(html, "digraph", "dot fence body preserved");
+    apex_free_string(html);
+
+    const char *graphviz_fence =
+        "```{graphviz}\n"
+        "graph { A -- B; }\n"
+        "```\n";
+    html = apex_markdown_to_html(graphviz_fence, strlen(graphviz_fence), &opts);
+    assert_contains(html, "<pre class=\"graphviz\">", "graphviz fence renders pre.graphviz");
+    assert_contains(html, "graph { A -- B", "graphviz fence body preserved");
+    apex_free_string(html);
+
+    apex_options no_diagrams_opts = apex_options_for_mode(APEX_MODE_QUARTO);
+    no_diagrams_opts.enable_quarto_diagrams = false;
+    html = apex_markdown_to_html(mermaid_fence, strlen(mermaid_fence), &no_diagrams_opts);
+    assert_contains(html, "<code", "disabled quarto diagrams keeps mermaid as code fence");
+    assert_not_contains(html, "class=\"mermaid\"", "disabled quarto diagrams skips pre.mermaid");
+    apex_free_string(html);
+
+    apex_options no_unsafe_opts = apex_options_for_mode(APEX_MODE_QUARTO);
+    no_unsafe_opts.unsafe = false;
+    html = apex_markdown_to_html(mermaid_fence, strlen(mermaid_fence), &no_unsafe_opts);
+    assert_contains(html, "<code", "no-unsafe keeps mermaid fence as code block");
+    assert_not_contains(html, "class=\"mermaid\"", "no-unsafe skips raw pre.mermaid");
+    apex_free_string(html);
+
+    apex_options standalone_opts = apex_options_for_mode(APEX_MODE_QUARTO);
+    standalone_opts.standalone = true;
+    html = apex_markdown_to_html(mermaid_fence, strlen(mermaid_fence), &standalone_opts);
+    assert_contains(html, "mermaid.min.js", "standalone quarto auto-injects mermaid script");
+    assert_contains(html, "</body>", "standalone mermaid output is full document");
+    apex_free_string(html);
+
+    apex_options standalone_with_script = apex_options_for_mode(APEX_MODE_QUARTO);
+    standalone_with_script.standalone = true;
+    standalone_with_script.script_tags = (char *[]){ strdup("<!-- mermaid already -->"), NULL };
+    html = apex_markdown_to_html(mermaid_fence, strlen(mermaid_fence), &standalone_with_script);
+    assert_not_contains(html, "mermaid.min.js", "standalone skips auto mermaid when script_tags mention mermaid");
+    assert_contains(html, "<!-- mermaid already -->", "standalone preserves user script_tags");
+    apex_free_string(html);
+    free(standalone_with_script.script_tags[0]);
+
+    const char *pagebreak_shortcode = "Page 1\n\n{{< pagebreak >}}\n\nPage 2";
+    html = apex_markdown_to_html(pagebreak_shortcode, strlen(pagebreak_shortcode), &opts);
+    assert_contains(html, "page-break-after", "pagebreak shortcode renders page break");
+    assert_contains(html, "Page 2", "content after pagebreak shortcode preserved");
+    assert_not_contains(html, "{{< pagebreak >}}", "pagebreak shortcode marker stripped");
+    apex_free_string(html);
+
+    const char *kbd_shortcode = "Press {{< kbd $@3 >}} to save.";
+    html = apex_markdown_to_html(kbd_shortcode, strlen(kbd_shortcode), &opts);
+    assert_contains(html, "{% kbd $@3 %}", "kbd shortcode converts to liquid tag");
+    assert_not_contains(html, "{{< kbd", "kbd shortcode marker stripped");
+    apex_free_string(html);
+
+    apex_options include_opts = apex_options_for_mode(APEX_MODE_QUARTO);
+    include_opts.enable_file_includes = true;
+#ifdef TEST_FIXTURES_DIR
+    include_opts.base_directory = TEST_FIXTURES_DIR;
+#else
+    include_opts.base_directory = "tests/fixtures/includes";
+#endif
+    const char *include_shortcode = "Before\n\n{{< include simple.md >}}\n\nAfter";
+    html = apex_markdown_to_html(include_shortcode, strlen(include_shortcode), &include_opts);
+    assert_contains(html, "Included Content", "include shortcode expands file content");
+    assert_contains(html, "After", "content after include shortcode preserved");
+    assert_not_contains(html, "{{< include", "include shortcode marker stripped");
+    apex_free_string(html);
+
+    apex_options no_shortcodes_opts = apex_options_for_mode(APEX_MODE_QUARTO);
+    no_shortcodes_opts.enable_quarto_shortcodes = false;
+    html = apex_markdown_to_html(pagebreak_shortcode, strlen(pagebreak_shortcode), &no_shortcodes_opts);
+    assert_contains(html, "{{< pagebreak", "disabled quarto shortcodes leave marker in output");
+    assert_not_contains(html, "page-break-after", "disabled quarto shortcodes skip pagebreak expansion");
+    apex_free_string(html);
+
+    const char *unknown_shortcode = "Text {{< widget foo >}} end.";
+    html = apex_markdown_to_html(unknown_shortcode, strlen(unknown_shortcode), &opts);
+    assert_contains(html, "{{< widget foo", "unknown shortcode left unchanged");
+    apex_free_string(html);
+
+    const char *empty_div_reset =
+        "1. First\n\n::: {}\n\n1. Second\n";
+    html = apex_markdown_to_html(empty_div_reset, strlen(empty_div_reset), &opts);
+    assert_contains(html, "<ol>", "empty div list reset produces ordered lists");
+    {
+        const char *first_ol = strstr(html, "<ol>");
+        const char *second_ol = first_ol ? strstr(first_ol + 1, "<ol>") : NULL;
+        test_result(second_ol != NULL, "empty div separates two ordered lists");
+    }
+    apex_free_string(html);
+
+    const char *cross_ref = "See @fig-elephant and @sec-intro for details.";
+    html = apex_markdown_to_html(cross_ref, strlen(cross_ref), &opts);
+    assert_contains(html, "<span class=\"quarto-xref\">@fig-elephant</span>", "fig cross-ref wrapped");
+    assert_contains(html, "<span class=\"quarto-xref\">@sec-intro</span>", "sec cross-ref wrapped");
+    apex_free_string(html);
+
+    {
+        apex_options cite_opts = apex_options_for_mode(APEX_MODE_QUARTO);
+        cite_opts.base_directory = "tests";
+        const char *bib_files[] = { "test_refs.bib", NULL };
+        cite_opts.bibliography_files = (char **)bib_files;
+        const char *mixed_cite_xref =
+            "See [@doe99] and @fig-elephant.";
+        html = apex_markdown_to_html(mixed_cite_xref, strlen(mixed_cite_xref), &cite_opts);
+        assert_contains(html, "citation", "bracket citation processed with bibliography");
+        assert_contains(html, "doe99", "bracket citation key preserved with bibliography");
+        assert_contains(html, "<span class=\"quarto-xref\">@fig-elephant</span>",
+                        "bare fig xref not parsed as citation when bibliography set");
+        assert_not_contains(html, "data-cites=\"fig-elephant\"", "fig xref not in citation data-cites");
+        apex_free_string(html);
+
+        const char *bracket_fig = "See [@fig-elephant].";
+        html = apex_markdown_to_html(bracket_fig, strlen(bracket_fig), &cite_opts);
+        assert_contains(html, "citation", "bracketed @fig- key still processed as citation");
+        assert_contains(html, "fig-elephant", "bracketed fig- citation key preserved");
+        apex_free_string(html);
+
+        apex_options no_xref_opts = cite_opts;
+        no_xref_opts.enable_quarto_xrefs = false;
+        const char *bare_fig = "See @fig-elephant.";
+        html = apex_markdown_to_html(bare_fig, strlen(bare_fig), &no_xref_opts);
+        assert_contains(html, "citation", "bare @fig- treated as citation when quarto-xrefs off");
+        assert_not_contains(html, "quarto-xref", "no xref wrapper when quarto-xrefs off");
+        apex_free_string(html);
+    }
+
+    apex_options hidden_opts = apex_options_for_mode(APEX_MODE_QUARTO);
+    hidden_opts.standalone = true;
+    html = apex_markdown_to_html("::: {.hidden}\nHidden content.\n:::", 35, &hidden_opts);
+    assert_contains(html, "class=\"hidden\"", "hidden div class preserved");
+    assert_contains(html, ".hidden { display: none; }", "standalone quarto CSS hides .hidden");
+    apex_free_string(html);
+
+    apex_options unified_opts2 = apex_options_for_mode(APEX_MODE_UNIFIED);
+    unified_opts2.enable_quarto_extensions = false;
+    html = apex_markdown_to_html("```{.python}\nx\n```", 18, &unified_opts2);
+    assert_contains(html, "{.python}", "non-quarto mode keeps braced fence info string");
+    apex_free_string(html);
+
+    bool had_failures = suite_end(suite_failures);
+    print_suite_title("Quarto Mode Tests", had_failures, false);
+}
+
 /**
  * Test cmark_init callback for custom extension registration
  */
@@ -401,6 +790,87 @@ void test_multimarkdown_image_attributes(void) {
         apex_free_string(html);
     }
 
+    /* Picture conversion should preserve image IAL attrs on fallback <img> */
+    {
+        apex_options opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+        const char *picture_ial_md =
+            "[![text-basic widget screenshot](img/text-basic.jpg avif @2x){:loading=lazy width=400 height=400}]"
+            "(img/text-basic@2x.jpg){.widget-shot.js-lightbox}";
+        char *html = apex_markdown_to_html(picture_ial_md, strlen(picture_ial_md), &opts);
+        assert_contains(html, "<a href=\"img/text-basic@2x.jpg\" class=\"widget-shot js-lightbox\">",
+                        "picture+ial: outer link classes preserved");
+        assert_contains(html, "<picture>", "picture+ial: picture element");
+        assert_contains(html, "img/text-basic.avif 1x, img/text-basic@2x.avif 2x",
+                        "picture+ial: avif srcset with @2x");
+        assert_contains(html,
+                        "<img src=\"img/text-basic.jpg\" alt=\"text-basic widget screenshot\" width=\"400\" height=\"400\" loading=\"lazy\">",
+                        "picture+ial: fallback img preserves IAL attrs");
+        apex_free_string(html);
+    }
+
+    /* Raw HTML <a> must not steal/drop later markdown link IAL classes */
+    {
+        apex_options opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+        opts.enable_autolink = false;
+        opts.enable_image_captions = false;
+        const char *md =
+            "<div class=\"note\">\n"
+            "<p>See <a href=\"/integrations#getting-started\">Integrations</a>.</p>\n"
+            "</div>\n\n"
+            "- [![alt](/x.jpg avif){:loading=lazy width=400 height=400}]"
+            "(/x@2x.jpg){.widget-shot.js-lightbox}\n"
+            "{.g}\n";
+        char *html = apex_markdown_to_html(md, strlen(md), &opts);
+        assert_contains(html,
+            "<a href=\"/x@2x.jpg\" class=\"widget-shot js-lightbox\">",
+            "raw html <a> must not steal/drop later link IAL classes");
+        assert_contains(html,
+            "href=\"/integrations#getting-started\">Integrations</a>",
+            "raw html callout link remains unchanged");
+        assert_not_contains(html,
+            "href=\"/integrations#getting-started\" class=\"widget-shot",
+            "IAL must not be injected onto the raw html <a>");
+        apex_free_string(html);
+    }
+
+    /* Distinct href IALs after a raw HTML <a> keep correct classes */
+    {
+        apex_options opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+        opts.enable_autolink = false;
+        const char *md =
+            "<p><a href=\"/raw\">Raw</a></p>\n\n"
+            "[One](/one){.class-one}\n\n"
+            "[Two](/two){.class-two}\n";
+        char *html = apex_markdown_to_html(md, strlen(md), &opts);
+        assert_contains(html, "<a href=\"/one\" class=\"class-one\">",
+                        "distinct href after raw <a>: first link IAL");
+        assert_contains(html, "<a href=\"/two\" class=\"class-two\">",
+                        "distinct href after raw <a>: second link IAL");
+        assert_not_contains(html, "href=\"/raw\" class=",
+                            "distinct href after raw <a>: raw link unchanged");
+        apex_free_string(html);
+    }
+
+    /* Same-href markdown links after raw HTML <a>: disambiguate by order */
+    {
+        apex_options opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+        opts.enable_autolink = false;
+        const char *md =
+            "<p><a href=\"/same\">Raw</a></p>\n\n"
+            "[First](/same){.first}\n\n"
+            "[Second](/same){.second}\n";
+        char *html = apex_markdown_to_html(md, strlen(md), &opts);
+        assert_contains(html, "<a href=\"/same\" class=\"first\">First</a>",
+                        "same href after raw <a>: first markdown link IAL");
+        assert_contains(html, "<a href=\"/same\" class=\"second\">Second</a>",
+                        "same href after raw <a>: second markdown link IAL");
+        assert_not_contains(html, "href=\"/same\" class=\"first\">Raw",
+                            "same href after raw <a>: raw link not given first IAL");
+        assert_not_contains(html, "href=\"/same\" class=\"second\">Raw",
+                            "same href after raw <a>: raw link not given second IAL");
+        apex_free_string(html);
+    }
+
     /* Video URL: ![alt](video.mp4) emits <video> */
     {
         apex_options opts = apex_options_for_mode(APEX_MODE_UNIFIED);
@@ -566,6 +1036,21 @@ void test_file_includes(void) {
     assert_contains(html, "Included Content", "MMD transclusion works");
     apex_free_string(html);
 
+    apex_options plugin_opts = opts;
+    plugin_opts.enable_plugins = true;
+    plugin_opts.allow_external_plugin_detection = false;
+    plugin_opts.plugin_register = include_preparse_plugin_register;
+    html = apex_markdown_to_html("Include: {{simple.md}}", 22, &plugin_opts);
+    assert_contains(html, "Plugin Included Content", "Included file runs through pre-parse plugin pipeline");
+    apex_free_string(html);
+
+    const char *plugin_section_include = "![[sections#Section 2]]";
+    html = apex_markdown_to_html(plugin_section_include, strlen(plugin_section_include), &plugin_opts);
+    assert_contains(html, "Plugin Section 2", "Section include resolves before plugin rewrites section heading");
+    assert_contains(html, "Nested section 2.1 text.", "Section include with plugin keeps nested subsection");
+    assert_not_contains(html, "Section 3 text.", "Section include with plugin still stops at next same-level heading");
+    apex_free_string(html);
+
     /* Test MMD wildcard transclusion: file.* (legacy behavior) */
     html = apex_markdown_to_html("Include: {{simple.*}}", 22, &opts);
     assert_contains(html, "Included Content", "MMD wildcard file.* resolves to simple.md");
@@ -697,6 +1182,63 @@ void test_file_includes(void) {
     assert_not_contains(html, "Included Content", "Line range excludes header");
     apex_free_string(html);
 
+    /* Section extraction parity across include syntaxes */
+    const char *mmd_section_include = "{{sections.md#Section 2}}";
+    html = apex_markdown_to_html(mmd_section_include, strlen(mmd_section_include), &opts);
+    assert_contains(html, "Section 2 text.", "MMD section include: selected section content");
+    assert_contains(html, "Nested section 2.1 text.", "MMD section include: nested subsection included");
+    assert_not_contains(html, "Section 3 text.", "MMD section include: stops before next same-level heading");
+    apex_free_string(html);
+
+    const char *marked_section_include = "<<[sections.md#Section 2]";
+    html = apex_markdown_to_html(marked_section_include, strlen(marked_section_include), &opts);
+    assert_contains(html, "Section 2 text.", "Marked section include: selected section content");
+    assert_contains(html, "Nested section 2.1 text.", "Marked section include: nested subsection included");
+    assert_not_contains(html, "Section 3 text.", "Marked section include: stops before next same-level heading");
+    apex_free_string(html);
+
+    const char *ia_section_include = "/sections.md#Section 2";
+    html = apex_markdown_to_html(ia_section_include, strlen(ia_section_include), &opts);
+    assert_contains(html, "Section 2 text.", "iA Writer section include: selected section content");
+    assert_contains(html, "Nested section 2.1 text.", "iA Writer section include: nested subsection included");
+    assert_not_contains(html, "Section 3 text.", "iA Writer section include: stops before next same-level heading");
+    apex_free_string(html);
+
+    const char *obsidian_section_include = "![[sections#Section 2]]";
+    html = apex_markdown_to_html(obsidian_section_include, strlen(obsidian_section_include), &opts);
+    assert_contains(html, "Section 2 text.", "Obsidian embed include: selected section content");
+    assert_contains(html, "Nested section 2.1 text.", "Obsidian embed include: nested subsection included");
+    assert_not_contains(html, "Section 3 text.", "Obsidian embed include: stops before next same-level heading");
+    apex_free_string(html);
+
+    opts.wikilink_extension = "txt";
+    html = apex_markdown_to_html(obsidian_section_include, strlen(obsidian_section_include), &opts);
+    assert_contains(html, "Section 2 text from TXT fixture.", "Obsidian embed include: uses --wikilink-extension default");
+    assert_not_contains(html, "Nested section 2.1 text.", "Obsidian embed include: extension override changes source file");
+    assert_not_contains(html, "Section 3 text from TXT fixture.", "Obsidian embed include: extension override still trims to section");
+    apex_free_string(html);
+    opts.wikilink_extension = ".txt";
+    html = apex_markdown_to_html(obsidian_section_include, strlen(obsidian_section_include), &opts);
+    assert_contains(html, "Section 2 text from TXT fixture.", "Obsidian embed include: dot-prefixed wikilink extension works");
+    apex_free_string(html);
+    opts.wikilink_extension = "html";
+    html = apex_markdown_to_html(obsidian_section_include, strlen(obsidian_section_include), &opts);
+    assert_contains(html, "Section 2 text.", "Obsidian embed include: falls back to .md when configured extension file is missing");
+    apex_free_string(html);
+    opts.wikilink_extension = NULL;
+
+    const char *missing_section_obsidian = "![[sections#Does Not Exist]]";
+    html = apex_markdown_to_html(missing_section_obsidian, strlen(missing_section_obsidian), &opts);
+    assert_contains(html, "Intro paragraph.", "Obsidian embed include: missing section falls back to full document");
+    assert_contains(html, "Section 3 text.", "Obsidian embed include: full document fallback includes later sections");
+    apex_free_string(html);
+
+    const char *missing_section_mmd = "{{sections.md#Does Not Exist}}";
+    html = apex_markdown_to_html(missing_section_mmd, strlen(missing_section_mmd), &opts);
+    assert_contains(html, "Intro paragraph.", "MMD include: missing section falls back to full document");
+    assert_contains(html, "Section 3 text.", "MMD include: full document fallback includes later sections");
+    apex_free_string(html);
+
     /* Test Marked code include with address syntax */
     html = apex_markdown_to_html("<<(code.py)[1,3]", 18, &opts);
     assert_contains(html, "def hello()", "Code include with line range");
@@ -711,7 +1253,7 @@ void test_file_includes(void) {
     assert_not_contains(html, "Included Content", "Regex range excludes before first match");
     apex_free_string(html);
 
-    /* Verify iA Writer syntax is NOT affected (no address syntax) */
+    /* iA Writer plain include still includes full file when no section is requested */
     html = apex_markdown_to_html("/code.py", 8, &opts);
     assert_contains(html, "def hello()", "iA Writer syntax unchanged");
     assert_contains(html, "return True", "iA Writer includes full file");
@@ -927,6 +1469,107 @@ void test_definition_lists(void) {
     assert_not_contains(html, "<dt>term</dt>", "No definition list from multi-line inline code");
     apex_free_string(html);
 
+    /* Leanpub {::pagebreak /} must not trigger definition list reordering */
+    const char *heading_pagebreak = "## Page breaks\n    {::pagebreak /}";
+    html = apex_markdown_to_html(heading_pagebreak, strlen(heading_pagebreak), &opts);
+    assert_contains(html, "<h2", "Heading before indented Leanpub pagebreak marker");
+    assert_contains(html, "Page", "Heading text preserved");
+    assert_contains(html, "<pre><code>{::pagebreak /}", "Leanpub pagebreak marker in code block");
+    assert_not_contains(html, "<dl>", "Leanpub pagebreak marker did not create definition list");
+    const char *h2_pos = strstr(html, "<h2");
+    const char *pre_pos = strstr(html, "<pre>");
+    if (h2_pos && pre_pos && h2_pos < pre_pos) {
+        test_result(true, "Heading appears before code block with Leanpub pagebreak marker");
+    } else {
+        test_result(false, "Heading should appear before code block with Leanpub pagebreak marker");
+    }
+    apex_free_string(html);
+
+    /* Buffered term before fenced code block must not be discarded */
+    const char *term_before_code =
+        "You can now use these environment variables in your Run Command actions:\n\n"
+        "```bash\n"
+        "echo hello\n"
+        "```";
+    html = apex_markdown_to_html(term_before_code, strlen(term_before_code), &opts);
+    assert_contains(html, "Run Command actions", "Intro paragraph preserved before code block");
+    {
+        const char *intro_pos = strstr(html, "Run Command actions");
+        const char *code_pos = strstr(html, "<pre");
+        test_result(intro_pos && code_pos && intro_pos < code_pos,
+                    "Intro paragraph appears before fenced code block");
+    }
+    apex_free_string(html);
+
+    /* Fence immediately after definition list must become a real code block */
+    {
+        const char *dl_then_fence =
+            "Term\n"
+            ": Def\n"
+            "\n"
+            "```\n"
+            "code\n"
+            "```\n";
+        html = apex_markdown_to_html(dl_then_fence, strlen(dl_then_fence), &opts);
+        assert_contains(html, "<dl>", "DL before bare fence still renders");
+        assert_contains(html, "<pre", "Bare fence after DL becomes pre/code");
+        assert_contains(html, "<code", "Bare fence after DL contains code element");
+        assert_not_contains(html, "</dl>\n```", "Fence after DL is not left as raw backticks");
+        apex_free_string(html);
+    }
+
+    /* Paragraph between DL and fence stays before the fence */
+    {
+        const char *dl_para_fence =
+            "Term\n"
+            ": Def\n"
+            "\n"
+            "This should stay before the diagram\n"
+            "\n"
+            "```mermaid\n"
+            "graph TD\n"
+            "  A --> B\n"
+            "```\n";
+        html = apex_markdown_to_html(dl_para_fence, strlen(dl_para_fence), &opts);
+        const char *para = strstr(html, "This should stay before the diagram");
+        const char *pre = strstr(html, "<pre");
+        test_result(para && pre && para < pre,
+                    "Paragraph between DL and fence stays before pre");
+        apex_free_string(html);
+    }
+
+    /* DL + callout + following paragraph: blanks must not be eaten */
+    {
+        apex_options callout_opts = apex_options_default();
+        callout_opts.mode = APEX_MODE_UNIFIED;
+        callout_opts.enable_callouts = true;
+        callout_opts.enable_definition_lists = true;
+        const char *dl_callout =
+            "Term\n"
+            ": Def\n"
+            "\n"
+            "> [!Note]\n"
+            "> note body\n"
+            "\n"
+            "After callout\n";
+        html = apex_markdown_to_html(dl_callout, strlen(dl_callout), &callout_opts);
+        assert_contains(html, "callout", "Callout after DL still renders");
+        assert_contains(html, "After callout", "Paragraph after callout preserved");
+        /* "After callout" must not sit inside the callout content blockquote */
+        const char *after = strstr(html, "After callout");
+        const char *callout_end = strstr(html, "</div>\n</div>");
+        if (!callout_end) callout_end = strstr(html, "callout-content");
+        test_result(after != NULL, "After callout text present in output");
+        if (after && strstr(html, "callout-content")) {
+            /* Find the callout-content section and ensure After is outside it */
+            const char *content = strstr(html, "callout-content");
+            const char *content_close = content ? strstr(content, "</div>") : NULL;
+            test_result(content_close && after > content_close,
+                        "After callout is outside callout-content");
+        }
+        apex_free_string(html);
+    }
+
     bool had_failures = suite_end(suite_failures);
     print_suite_title("Definition Lists Tests", had_failures, false);
 }
@@ -994,6 +1637,68 @@ void test_callouts(void) {
     }
     apex_free_string(html);
 
+    /* Python-Markdown callouts are disabled by default */
+    const char *py_callout = "!!! note \"Py Title\"\n    Py body line";
+    html = apex_markdown_to_html(py_callout, strlen(py_callout), &opts);
+    assert_not_contains(html, "class=\"callout", "Python callout syntax ignored when flag disabled");
+    apex_free_string(html);
+
+    /* Python-Markdown callouts enabled behind flag */
+    opts.enable_py_callouts = true;
+    html = apex_markdown_to_html(py_callout, strlen(py_callout), &opts);
+    assert_contains(html, "class=\"callout", "Python callout recognized when enabled");
+    assert_contains(html, "callout-note", "Python note callout type");
+    assert_contains(html, "Py Title", "Python callout title preserved");
+    apex_free_string(html);
+    opts.enable_py_callouts = false;
+
+    /* markdown-callouts NOTE: syntax enabled behind py flag */
+    opts.enable_py_callouts = true;
+    html = apex_markdown_to_html("NOTE: Inline py callout body", 28, &opts);
+    assert_contains(html, "class=\"callout", "NOTE: syntax recognized with py-callouts");
+    assert_contains(html, "callout-note", "NOTE: maps to note callout");
+    assert_contains(html, "Inline py callout body", "NOTE: body preserved");
+    apex_free_string(html);
+
+    /* markdown-callouts collapsed syntax */
+    const char *collapsed_py = ">? NOTE: Collapsed note\n> Collapsed body";
+    html = apex_markdown_to_html(collapsed_py, strlen(collapsed_py), &opts);
+    assert_contains(html, "<details", ">? syntax creates collapsible callout");
+    assert_contains(html, "callout-note", ">? NOTE maps to note callout");
+    assert_contains(html, "Collapsed body", ">? NOTE body preserved");
+    apex_free_string(html);
+
+    opts.enable_py_callouts = false;
+
+    /* Quarto callouts are disabled by default */
+    const char *quarto_callout =
+        "::: {.callout-warning}\n"
+        "## Quarto Title\n"
+        "Quarto warning body.\n"
+        ":::\n";
+    html = apex_markdown_to_html(quarto_callout, strlen(quarto_callout), &opts);
+    assert_not_contains(html, "class=\"callout callout-warning\"", "Quarto callout syntax ignored when flag disabled");
+    apex_free_string(html);
+
+    /* Quarto callouts enabled behind flag */
+    opts.enable_quarto_callouts = true;
+    html = apex_markdown_to_html(quarto_callout, strlen(quarto_callout), &opts);
+    assert_contains(html, "class=\"callout", "Quarto callout recognized when enabled");
+    assert_contains(html, "callout-warning", "Quarto warning callout type");
+    assert_contains(html, "Quarto warning body", "Quarto callout body preserved");
+    apex_free_string(html);
+
+    /* Quarto flag should still allow non-callout divs to render as divs */
+    const char *regular_div =
+        "::: {.sidebar}\n"
+        "Regular div content.\n"
+        ":::\n";
+    html = apex_markdown_to_html(regular_div, strlen(regular_div), &opts);
+    assert_contains(html, "<div class=\"sidebar\"", "Non-callout fenced div still rendered with Quarto mode enabled");
+    assert_not_contains(html, "class=\"callout", "Non-callout fenced div not converted into callout");
+    apex_free_string(html);
+    opts.enable_quarto_callouts = false;
+
     bool had_failures = suite_end(suite_failures);
     print_suite_title("Callouts Tests", had_failures, false);
 }
@@ -1063,6 +1768,28 @@ void test_blockquote_lists(void) {
     /* Definition lists may or may not be parsed depending on mode */
     apex_free_string(html);
 
+    /* Reference image after blockquote without blank line should not stay in blockquote */
+    const char *ref_img_after_quote =
+        "> Block quote\n"
+        "![][2]\n"
+        "\n"
+        "[2]: /path/to/image.jpg\n"
+        "\n"
+        "Additional paragraph.";
+    html = apex_markdown_to_html(ref_img_after_quote, strlen(ref_img_after_quote), &opts);
+    assert_contains(html, "<blockquote>", "Blockquote present for ref image test");
+    assert_contains(html, "Block quote", "Blockquote text preserved");
+    assert_not_contains(html, "<blockquote>\n<p>Block quote\n<img", "Reference image not lazy-continued into blockquote");
+    assert_contains(html, "<img src=\"/path/to/image.jpg\"", "Reference image resolved outside blockquote");
+    assert_contains(html, "Additional paragraph.", "Paragraph after reference image preserved");
+    apex_free_string(html);
+
+    /* Inline image after blockquote without blank line */
+    html = apex_markdown_to_html("> Block quote\n![alt](test.png)\n\nNext paragraph.", 52, &opts);
+    assert_not_contains(html, "<blockquote>\n<p>Block quote\n<", "Inline image not inside blockquote paragraph");
+    assert_contains(html, "test.png", "Inline image rendered outside blockquote");
+    apex_free_string(html);
+
     bool had_failures = suite_end(suite_failures);
     print_suite_title("Blockquote Lists Tests", had_failures, false);
 }
@@ -1120,6 +1847,31 @@ void test_html_markdown_attributes(void) {
     assert_contains(html, "<div>", "HTML preserved without markdown attribute");
     apex_free_string(html);
 
+    /* Reference-style links in markdown="1" blocks resolve definitions from full document */
+    const char *ref_in_block =
+        "<blockquote class=\"tip\" markdown=\"1\">\n"
+        "See the [extension page][ext] for details.\n"
+        "</blockquote>\n\n"
+        "[ext]: https://example.com/ext \"Extension page\"";
+    html = apex_markdown_to_html(ref_in_block, strlen(ref_in_block), &opts);
+    assert_contains(html, "<a href=\"https://example.com/ext\"", "markdown=\"1\" resolves reference-style links");
+    assert_contains(html, "extension page</a>", "markdown=\"1\" reference link text preserved");
+    apex_free_string(html);
+
+    /* Reference footnotes in markdown="1" blocks resolve definitions from full document */
+    const char *fn_in_block =
+        "<blockquote class=\"tip\" markdown=\"1\">\n"
+        "See footnote[^note] here.\n"
+        "</blockquote>\n\n"
+        "[^note]: Footnote text.";
+    html = apex_markdown_to_html(fn_in_block, strlen(fn_in_block), &opts);
+    assert_contains(html, "class=\"footnote-ref\"", "markdown=\"1\" resolves reference footnotes");
+    assert_contains(html, "href=\"#fn-note\"", "markdown=\"1\" footnote links to block anchor");
+    assert_contains(html, "<section class=\"footnotes\"", "markdown=\"1\" footnotes section rendered in block");
+    assert_contains(html, "Footnote text.", "markdown=\"1\" footnote definition rendered in block");
+    assert_not_contains(html, "See footnote[^note]", "markdown=\"1\" footnote not left literal");
+    apex_free_string(html);
+
     bool had_failures = suite_end(suite_failures);
     print_suite_title("HTML Markdown Attributes Tests", had_failures, false);
 }
@@ -1506,6 +2258,37 @@ void test_abbreviations(void) {
     assert_contains(html, "<abbr title=\"abbreviation syntax\">ABBR</abbr>", "Inline abbr when mixed");
     apex_free_string(html);
 
+    /* Regression for issue #31: preprocessing must preserve physical lines
+     * longer than the old 1024-byte abbreviation and 2048-byte ALD buffers. */
+    const char *tail_marker = "END-OF-LONG-LINE";
+    const size_t prefix_len = 2160;
+    size_t marker_len = strlen(tail_marker);
+    char *long_line = malloc(prefix_len + marker_len + 2);
+    if (long_line) {
+        memset(long_line, 'a', prefix_len);
+        memcpy(long_line + prefix_len, tail_marker, marker_len);
+        long_line[prefix_len + marker_len] = '\n';
+        long_line[prefix_len + marker_len + 1] = '\0';
+
+        const apex_mode_t modes[] = {
+            APEX_MODE_MULTIMARKDOWN,
+            APEX_MODE_KRAMDOWN,
+            APEX_MODE_UNIFIED,
+            APEX_MODE_QUARTO
+        };
+        const char *mode_names[] = {"MMD", "Kramdown", "Unified", "Quarto"};
+        for (size_t i = 0; i < sizeof(modes) / sizeof(modes[0]); i++) {
+            apex_options long_opts = apex_options_for_mode(modes[i]);
+            html = apex_markdown_to_html(long_line, strlen(long_line), &long_opts);
+            test_resultf(html && strstr(html, tail_marker) != NULL,
+                         "%s mode preserves lines longer than 2048 bytes", mode_names[i]);
+            apex_free_string(html);
+        }
+        free(long_line);
+    } else {
+        test_result(false, "Allocate issue #31 long-line regression input");
+    }
+
     bool had_failures = suite_end(suite_failures);
     print_suite_title("Abbreviations Tests", had_failures, false);
 }
@@ -1746,6 +2529,26 @@ void test_special_markers(void) {
     assert_contains(html, "Section 3", "Last section");
     apex_free_string(html);
 
+    /* Special markers NOT converted inside inline code span */
+    html = apex_markdown_to_html("`<!--PAUSE:15-->`", 17, &opts);
+    assert_contains(html, "<code>&lt;!--PAUSE:15--&gt;</code>", "Pause marker preserved in inline code");
+    assert_not_contains(html, "data-pause", "Pause marker not rendered in inline code");
+    apex_free_string(html);
+
+    /* Special markers NOT converted inside indented code block */
+    const char *indented_break = "    <!--BREAK-->";
+    html = apex_markdown_to_html(indented_break, strlen(indented_break), &opts);
+    assert_contains(html, "&lt;!--BREAK--&gt;", "Break marker preserved in indented code");
+    assert_not_contains(html, "page-break-after", "Break marker not rendered in indented code");
+    apex_free_string(html);
+
+    /* Special markers NOT converted inside fenced code block */
+    const char *fenced = "```\n<!--BREAK-->\n```";
+    html = apex_markdown_to_html(fenced, strlen(fenced), &opts);
+    assert_contains(html, "&lt;!--BREAK--&gt;", "Break marker preserved in fenced code");
+    assert_not_contains(html, "page-break-after", "Break marker not rendered in fenced code");
+    apex_free_string(html);
+
     bool had_failures = suite_end(suite_failures);
     print_suite_title("Special Markers Tests", had_failures, false);
 }
@@ -2265,12 +3068,29 @@ void test_mixed_lists(void) {
     html = apex_markdown_to_html(alpha_with_nested_alpha, strlen(alpha_with_nested_alpha), &unified_opts);
     assert_contains(html, "<ol style=\"list-style-type: lower-alpha\">", "Alpha list keeps style with nested alpha sublist");
     assert_not_contains(html, "[apex-alpha-list:", "No leaked alpha marker token after nested alpha sublist");
+    assert_not_contains(html, "<p>Test</p>\n<ol>", "Synthetic nested alpha sublist stays tight without paragraph wrapper");
+    apex_free_string(html);
+
+    /* Numeric parent list with indented alpha sublist → nested <ol style="lower-alpha"> */
+    const char *numeric_with_nested_alpha = "1. One\n2. Two\n\ta. Two-One\n\tb. Two-Two\n3. Three\n";
+    html = apex_markdown_to_html(numeric_with_nested_alpha, strlen(numeric_with_nested_alpha), &unified_opts);
+    assert_contains(html, "<ol style=\"list-style-type: lower-alpha\">",
+                    "Alpha sublist under numeric list gets lower-alpha styling");
+    assert_contains(html, "<li>Two-One</li>", "Nested alpha item text preserved");
+    assert_not_contains(html, "<!-- apex-alpha-list-", "Alpha HTML comment marker stripped from output");
     apex_free_string(html);
 
     const char *numeric_with_nested_ordered = "1. Test\n2. Test\n\t3. Test\n\t4. Test\n5. Test\n";
     html = apex_markdown_to_html(numeric_with_nested_ordered, strlen(numeric_with_nested_ordered), &unified_opts);
     assert_contains(html, "<ol start=\"3\">", "Numeric nested ordered sublist renders as nested ordered list");
     assert_not_contains(html, "2. Test\n    3. Test", "Nested ordered items are not flattened into parent text");
+    assert_not_contains(html, "<p>Test</p>\n<ol start=\"3\">", "Synthetic nested ordered list stays tight without paragraph wrapper");
+    apex_free_string(html);
+
+    const char *numeric_with_explicit_loose_nested_ordered = "1. Test\n2. Test\n\n\t3. Test\n\t4. Test\n5. Test\n";
+    html = apex_markdown_to_html(numeric_with_explicit_loose_nested_ordered, strlen(numeric_with_explicit_loose_nested_ordered), &unified_opts);
+    assert_contains(html, "<ol start=\"3\">", "Explicit blank line nested ordered sublist renders");
+    assert_contains(html, "<p>Test</p>\n<ol start=\"3\">", "Explicit blank line keeps loose list paragraph wrapper");
     apex_free_string(html);
 
     bool had_failures = suite_end(suite_failures);