html-to-markdown

Fixed

• base_url did not resolve a <blockquote cite>, and Tier 1 dropped the citation entirely. cite is a destination the converter renders — Tier 2 emits it as a trailing — <url> line — but it was the one such destination base_url left alone, so a relative citation stayed relative. Tier 1's blockquote handling read no attributes at all, so the same markup produced the citation on one tier and nothing on the other; a cited blockquote now bails to Tier 2, which is authoritative for it. Found while adopting base_url downstream, where a converter that resolves every destination except this one forces the caller to keep a whole link-rewriting pre-pass alive for it.

• The Go binding could read a different OS thread's FFI error slot. Convert, HeaderMetadata.IsValid and the visitor entry point now pin the goroutine for the duration of the cgo call with runtime.LockOSThread. The FFI layer keeps its last-error state in a thread_local! (crates/html-to-markdown-ffi/src/lib.rs:31), so without pinning the Go runtime was free to reschedule the goroutine between the call that stamped the error and the htm_last_error_code read that reports it — surfacing a nil error for a call that had in fact failed. Emitted by alef 0.97.0; no Go API changed.

Changed

• Repinned the alef generator to 0.97.0 and regenerated every binding. Apart from the Go thread pinning above, the only other generated change is the Kotlin Android Gradle wrapper moving from 9.7.1 to 9.8.0; everything else in the regeneration is version strings and provenance hashes.
• CI now gates the docs-site changelog mirror against CHANGELOG.md. The two are compared from the first ## [ heading onward rather than over [Unreleased] alone, because this repo releases straight out of [Unreleased] and leaves it empty on main — an Unreleased-only comparison would compare zero lines and pass while a released section drifted.

chore(release): substitute Swift checksum for 3.15.0

Added

• ConversionOptions::base_url resolves relative href/src destinations against a caller-supplied base URL, honoring a document's own <base href> the way a browser does. Defaults to None, so output is byte-identical for callers who do not set it. Resolution happens identically in both the Tier 1 and Tier 2 rendering paths.

Changed

• Upgraded rmcp to 3.4.1.
• Repinned the alef generator to 0.96.5 and regenerated every binding. Generator drift only; no public API of any binding changed.
• Split converter/utility/content.rs and converter/inline/link.rs (each over the 1000-line quality gate) into smaller modules, and reduced convert_table_row's cyclomatic complexity by extracting its visitor-hook pre-pass into a separate function. No behavior change; every existing import path is preserved via re-exports.

Fixed

• The R binding compiles again. ConversionOptions::base_url is the struct's first Option<String>, and alef's extendr backend assigned it a bare String, failing the whole R package build with error[E0308]: expected Option<String>, found String. Fixed in alef 0.96.5. It went unnoticed for two commits because two independent mechanisms each suppressed the leg. On the commit that introduced the line, Test: R was cancelled: ci-e2e.yaml's cancel-in-progress: true group is keyed on the branch, so the next push to main killed the run before R finished. On the commit after that, Test: R was skipped: the leg is gated on a packages/r/**/crates/html-to-markdown/** paths filter that commit did not match. Neither state is a failure, so CI E2E reported success twice without ever compiling R.

• CI's fixture-snippet validation now really validates the 341 Swift snippets. They had all been reporting Unavailable with no such module 'HtmlToMarkdown': Swift 6.3 made swiftbuild the default build system, whose bin path holds the .swiftmodule files directly and emits no Modules/ directory, while alef points -I at <bin-path>/Modules. The session now reconstructs that layout after building. The gate went red without any change to this tree, when the runner's preinstalled Swift moved to 6.4.

chore(release): substitute Swift checksum for 3.14.3

Fixed

• A whitespace-only inline wrapper nested inside another wrapper keeps its separator (#504). <h2><strong>Alpha</strong><strong><em><br></em></strong>Beta</h2> rendered ## **Alpha**Beta from 3.14.2 on, where 3.14.1 kept the space, and a paragraph or table cell joined the words the same way. Issue #501 taught the shared wrapper emitter that a whitespace-only body at a line start contributes nothing, keyed on the destination buffer being empty -- but the destination can also be an enclosing wrapper's fresh scratch buffer, which is empty mid-line, so the inner <em>'s one space was dropped there and the outer <strong> came out empty. The line-start rule now fires only on the block's own buffer, using the address test the text-node fallback already uses for the same distinction, so <mark>, <ins>, <del>, <sub> and <sup> wrappers move with it. A <br> inside a wrapper inside a table cell had the same shape on its own since before 3.14.2 -- <td>Alpha<em><br></em>Beta</td> -- and now keeps its space too; a cell's own leading <br> still contributes nothing. Tier 1 bails on adjacent emphasis, so the change is Tier-2 only.
• A newline inside nested transparent inline wrappers still separates the words around it (#505). <p><i>Alpha</i><span><span>\n</span></span>Beta</p> rendered *Alpha*Beta where a browser shows a space. Issues #430 and #491 taught the text-node fallback that a lone newline inside an inline wrapper separates words when the wrapper is followed by inline content, but the check looked one level up only: with a second wrapper the inner <span> is the last child of the outer one and the newline was dropped. The check now climbs through every transparent inline ancestor that has nothing after it and stops at the first block. Tier 1 already emitted the space, so this was a live cross-tier divergence; the tiers now agree.
• An anchor that html5ever's adoption agency splits around a block is emitted once, not twice (#493). <a href="/o"><div><a href="/i">Inner</a></div></a> rendered [](/o) and then [](/o)[Inner](/i): the repair legitimately closes the outer <a> at the <div> and reconstructs it inside, and the clone reached the renderer indistinguishable from an authored element. A renderer rule keyed on shape would either drop a genuine empty anchor (CommonMark example 484) or a deliberately authored duplicate, so the fix is at parse time: every <a> start tag is stamped with a private origin id before the tree builder sees it, the clones inherit it, and on the repaired tree the halves of a split anchor with no content of their own are unwrapped in place. When no half has content the authored one is kept, so the destination still appears once as [](/o); <a href="/o"><div>Text<a href="/i">Inner</a></div></a> keeps the half that carries Text and renders [Text](/o)[Inner](/i). Input the repair never runs on, and an anchor the repair leaves whole, are unchanged.

chore(release): substitute Swift checksum for 3.14.2

Fixed

• An & that would read as a character reference in a link destination or title now stays literal (#498). CommonMark decodes entity and numeric character references inside destinations and titles, so the decoded ?+ that <img src="?&amp;plus;"> produced from 3.14.0 on re-parsed as ?+ -- a different URL. <a href> and title had carried the same defect since 3.12, when they started decoding; only src was new to it. Such an & is now written back as &, the form 3.13 emitted and the one non-CommonMark consumers of the URL also read correctly. Only a reference the HTML5 decoder really recognises is touched: ?a&b and &foo; are unchanged. Tier 1 wrote a link's href straight into the output with no escaping at all, so it now shares Tier 2's append_url_destination; that also ends a divergence unrelated to entities, where Tier 1 emitted [T](/a b(c) and [T](/a(b) against Tier 2's [T](</a b(c>) and [T](/a\(b).
• An unmatched [ in a link label or image alt is now escaped (#499). CommonMark accepts a bracket in a label only escaped or as a matched pair; an unmatched ] was already escaped, an unmatched [ was not. <img alt="[A;B)" src="S"> rendered ![[A;B)](S), which re-parses as a dangling ! followed by a real [A;B)](S) link -- the image was gone. The shared escape_link_label helper now escapes every opener left without a closer, so both tiers and every caller (links, images, <graphic>, SVG titles, embedded media) move together.
• A run of ASCII whitespace at the start of a line is no longer emitted (#501). <p>P</p><div><span> </span><img alt="A" src="S"></div> rendered the image as ![A](S) indented by four columns, which CommonMark reads as an indented code block, so the image was lost. Issue #460 dropped leading whitespace at the start of a paragraph; a <div> never set that flag and the run fell through to the verbatim fallback. Leading ASCII whitespace on a line is never Markdown content, so the text-node fallback now drops it at a line start of the block's own buffer, the <div> handler measures its content start the way <p> does so an inline wrapper's empty scratch buffer is not mistaken for one (its single space must still reach the #481 handling), and a whitespace-only wrapper spliced in at a line start contributes nothing -- <p>A</p><p><i> </i>B</p> no longer opens its second paragraph with a stray space. A multi-space run mid-line collapses to one space, as it already did between two inline siblings. A run carrying a decoded   is untouched. Tier 1 already emitted every case this way.
• A whitespace-only inline wrapper body no longer vanishes and joins the words around it (#502). <b>Alpha</b><b><span>\n</span></b><b>Beta</b> rendered **AlphaBeta**, and Alpha<i>\n</i>Beta rendered AlphaBeta, where a browser shows a space. Two drops of one shape: a newline-only text node returned early because the wrapper's scratch buffer was empty -- the buffer is fresh per wrapper, so its length says nothing about the document -- and a <br> with nothing before it in that buffer left a bare newline that chomp_inline did not count as a space. Both now surface as the single separating space issue #481 already gives a literal <b> </b>, still suppressed after an existing space; a truly empty <b></b> still emits nothing. Tier 1 bails on every one of these shapes, so the change is Tier-2 only.
• A headerless table whose rows have different cell counts is padded, not turned into a list (#500). <table><tr><td>A</td><td>B</td></tr><tr><td>C</td></tr></table> rendered - A B / - C: ragged row lengths alone classified a table as a layout table. A headerless table with a short row is ordinary tabular data far more often than it is an email-signature grid, and the regular renderer already pads a short row to the table's width (issue #13), so it now renders | A | B |, | --- | --- |, | C | |. Layout still triggers on more than one nested table, colspan/rowspan combined with border="0", a blank table, or a short table dense with links. Tier 1 keeps its stricter bail on ragged rows -- it has no padding of its own -- which only ever sends more input to the path that does. A layout row also keeps an image as ![alt](src) instead of degrading it to alt text: the row is a list item, and list items and data cells keep images by default; only headings degrade them. keepInlineImagesIn is no longer needed for that (issue #433), though it still governs headings and links.
• A layout row stays on one line across a <br> or a blank nested table. A <br> inside a layout cell emitted a hard-break marker, and a nested table that rendered to nothing still emitted the blank line meant to separate content; either put a bare newline inside a list item's line and ended the item. Both were latent -- the Hacker News footer in the gh-121 fixture is <img><table>bar</table><br>links, and while the spacer image degraded to nothing every separator stayed suppressed -- and keeping the image surfaced them. A <br> now follows the settled cell rule its <div>/<p> continuations already use (issue #470), and an empty table output writes no separator. Across the benchmark corpus this rejoined three split list items in one fixture and changed nothing else; the other movements are images now kept in layout rows and leading whitespace dropped at line starts (#501).
• An anchor wrapping a table inside a layout cell keeps its inner links clickable (#503). Issue #490 renders a wrapped table as a separate block after the link, but refused inside inline contexts, and a cell of a table the layout heuristic turns into a bullet list converts as inline. The nested table was walked into the label instead, where the bracket escaping turned [One](/one) and [Two](/two) into text; only the outer destination survived. A layout cell is a list item's text, not a link label, and it already holds a bare nested table on the lines after its bullet, so the deferred table now lands there the same way. Headings and true inline labels keep refusing. Tier 1 bails on a table opened inside a link, so this is Tier-2 only.

chore(release): substitute Swift checksum for 3.14.1

Fixed

• A multi-line link label or image alt no longer has one of its lines read as block structure (#496). CommonMark parses block structure before inline structure (spec 0.31.2 appendix A), so a continuation line that looks like a block opener ends the paragraph the label lives in and the [/![ never reaches its ]. ![A\n-\n](S) produced no image at all -- it produced <h2>![A</h2><p>](S)</p>, with the image gone. A hard line break did not help, because it is inline and block parsing has already finished by then, so the reporter's escaping workarounds could not work either. Measured against comrak, 14 of 18 opener shapes destroyed the construct: setext - and =, all three thematic breaks, ATX headings, both code fences, block quotes, all three bullet markers, both ordered-list delimiters, and HTML blocks. The first non-blank character of a continuation line is now backslash-escaped when that line would open a block that can interrupt a paragraph -- ordered lists at their ./) delimiter, since a digit cannot carry an escape. Lines that open nothing are untouched: four columns of indent (indented code cannot interrupt a paragraph), a type-7 HTML block such as a bare <span>, 2. x, -x, seven #. The label's first line is never escaped -- it is preceded on that same line by the caller's own [/![. The escaping is unconditional, like the existing bracket escaping and unlike the escape_misc family: those decide whether text that merely looks like Markdown is emitted verbatim, this decides whether the image or link survives at all. Multi-line alt is not exotic -- TeX4ht emits it for every formula it cannot render. Both tiers were affected and both are fixed through the one escape_link_label helper they share.

• A <br> at the very start or end of an <a> is no longer dropped (#497). <a href="H">A<br></a>B renders as A, a line break, then B; the converter emitted [A](H)B, losing the break entirely. [A \n](H)B re-parses to exactly the original <a href="H">A<br /></a>B (verified against comrak), so the break belongs inside the label. Both tiers dropped it for the same reason expressed twice -- the whole label was whitespace-trimmed, and once flattened a " \n" marker is indistinguishable from the incidental whitespace that really does belong before a </a> -- and Tier 2 additionally never emitted a leading break at all, because its "nothing on this line yet" test compares a fresh label buffer's length against the enclosing block's start offset. A run of breaks at one edge still collapses to a single break (two adjacent markers would put a blank line in the label, and a blank line ends the paragraph, destroying the link), and a label of nothing but breaks still collapses to empty. A heading and a pipe-table cell are single-line and still fold every break to a space. The issue's second example asks for B[A \n](H), which moves the break to the far side of the label text; the break is preserved where the <br> actually was instead -- B[ \nA](H), which comrak renders back to the input DOM.

• Tier 1 no longer emits three spaces where Tier 2 emits one for a <br> inside a link inside a table cell (| [A - B](H) | against | [A - B](H) |). Tier 1 folded its hard-break marker late, in close_table_cell, which left the marker's two spaces behind; it now folds in close_link, which is also what keeps the #496 escaping from firing on a label that is about to become single-line anyway.

• Generated Go and R e2e suites no longer assert against strings their fixtures never specified (alef pin 0.90.0 to 0.91.5). Two independent generator defects were corrupting fixture values on their way into test code: alef's Go emitter rendered a multi-line value as a raw backtick literal and its own writer then trimmed the trailing whitespace off every physical line, so the three assertions carrying a Markdown two-space hard break read [Alpha\n](url)Beta where the fixture said [Alpha \n](url)Beta; and alef's R emitter ran every plain string argument through the PascalCase-to-snake_case transform meant only for enum wire values, so Alpha<span ...> was emitted as alpha<span ...> and Beta<a ...><br>Alpha</a> as beta<a ...><br>_alpha</a>. The R defect had been silently wrong since the 3.14.0 paragraph_whitespace_only_span_separates_words fixture landed; it went unnoticed because the E2E workflow had skipped every language test job on the three preceding commits, so "green" meant "nothing ran". Fixed upstream in alef 0.91.5 rather than by trimming the fixtures. The pin bump also carries alef 0.91.0-0.91.3, which for this repo is limited to a simpler argument-marshalling path in the Node visitor bridge (no API or behaviour change) and dropping its unused tokio-util dependency.

chore(release): substitute Swift checksum for 3.14.0

Changed

• Upgraded html5ever to 0.40.1, which fixes silent content loss on the HTML repair path. 0.40.0's serializer dropped the leading 0xC2 byte of a two-byte UTF-8 sequence, corrupting every character in U+0080..U+00BF except NBSP -- §, ©, °, · among them. Because repair_with_html5ever serializes the repaired tree back to a string for the primary parser to re-read, a single such character made the whole re-parse fail and everything after it vanish. This repo was pinned to 0.39.0 to avoid it; 0.40.1 carries the upstream fix, verified here by building the same tree against both versions rather than by trusting the release note. A regression test now pins the behaviour with non-ASCII fixtures -- the existing repair-path tests are ASCII-only and passed on the broken release, which is why the defect was invisible.
• Upgraded rmcp to 3.4.0. It deprecates the ServerInfo alias in favour of ServerConfig (the same type, renamed because it collided with the protocol's own serverInfo field), so the MCP server's get_info moved with it. No wire-visible change.

Fixed

• Character references in attribute values are now decoded (#494). <a href> was the only attribute in the converter that called the entity decoder, so every other user-visible attribute emitted its raw source text: title="A&B" reached the output as the literal A&B, and alt="it's" as it's. Twelve sites were affected -- title on <a>, <img>, <graphic> and <abbr>; alt on <img> and <graphic>; src on <img>, <audio>, <video>, <iframe> and <source>; cite on <blockquote>; the language- class on a code fence; and <meta content> in extracted metadata. They were found by probing every attribute that reaches output, not by reading the ones that looked likely. Attribute reads now go through one shared accessor so a new attribute cannot reopen the gap. The Markdown escaping is unchanged and was never at fault -- a literal " in a title was always escaped correctly; the decoded character simply never arrived. Tier 1 carried the same defect independently and moves in lockstep.

• Three Tier-1 divergences that entity decoding made reachable. Each was latent long before it could be triggered, and each is now pinned by a parity test. An <img> in a heading was emitted as ![alt](src) by the fast scanner whenever keepInlineImagesIn was empty, where the DOM path correctly replaces it with its alt text -- an empty list names no heading, so it permits nothing. A heading whose body merely ended in whitespace was never trimmed, because the trim only ran for bodies containing a newline; a decoded   therefore survived where the DOM path dropped it. And a link title containing a quote was escaped as " rather than \". The first two were found by the generated-corpus parity test over 3,000 documents, the third by a sweep over every character decoding newly makes reachable.

• A wrapper element no longer defeats the nested-table fix (#488). A nested <table> inside a <td> was detected with a single-node tag-name test over the cell's direct children, so wrapping it in a <div> bypassed the 3.12.4 deferral, the pipe escaping and the row fold all at once. The inner table's raw | characters then read as the outer row's cell boundaries on reparse -- content loss, not a cosmetic diff. The nested-table counter has always descended through wrappers; the two now agree. The same line fixes the sibling-cell shape, which was corrupt in the same way.

• Content after a table whose last row is never closed is no longer lost (#489). In <table>...<tr></table><p>Visible footer</p>, the primary parser discards a close tag that does not match the top of its open-element stack, so </table> vanished and the paragraph was adopted by the still-open <tr> -- where the cell collector, which keeps only td/th, dropped it. Such a document now takes the same html5ever repair path that #336, #479 and #486 already use. A row that yields no cells also stops emitting a phantom empty row, so the next real row becomes the header, matching Tier 1. Two further shapes are fixed by the same gate: a second <tr> opened without closing the first (its row was silently dropped) and a <td> placed directly inside <tbody> (which produced no output at all). Text-only children are deliberately excluded from the gate, so a <tr>&nbsp;</tr> spacer does not pay for a full re-parse.

• An anchor wrapping a table renders the table, not an escaped link label (#490). Any block content inside an <a> became link-label content, so <a href="..."><table>...</table></a> crushed the whole table into a single label -- and the label escaper then correctly escaped the markdown that produced, leaving an unreadable run of \|. The escaping was never the bug; handing a table to the label builder was. The anchor's direct children are now partitioned, the inline half forms the label and the deferred half renders as blocks after it. Only a deferred subtree that actually contains a <table> triggers this, and never inside a heading or an inline context, so every other anchor shape is byte-identical.

• A whitespace-only inline wrapper still separates the words around it (#491). Alpha<span style="white-space:pre">\n</span>13 rendered as Alpha13. The predicate added for #430 asks whether the next sibling is an element, so a bare text node after the wrapper took the failing path and the newline vanished. Tier 1 was already correct, so the two tiers disagreed on this input; they are now pinned together by a parity test. Note that the reported white-space: pre is incidental -- that property is not implemented, and the defect reproduced without it, exactly as a browser collapses the newline to a space either way. The wrapper contributes a separator only when the next word butts straight up against it; text that already opens with whitespace supplies its own, and is left alone.

• keepInlineImagesIn now means something for <a> (#492). The option was consulted for headings and for layout cells, but never for anchors, so an <img> inside a link that also held a block element was replaced by its alt text (or dropped entirely when it had none) no matter what the option said. Listing "a" now keeps the image as markdown, in both the block and inline anchor paths, and for <graphic> as well as <img>. The change is purely additive -- it can turn an image on, never off -- so output is byte-identical for anyone not naming "a" in the option. The Tier-1 scanner was updated in lockstep.

chore(release): substitute Swift checksum for 3.13.0

Changed

• BREAKING (java): enum constants are now SCREAMING_SNAKE_CASE. LinkStyle.Inline becomes LinkStyle.INLINE, HeadingStyle.Atx becomes HeadingStyle.ATX, and so on across every generated enum; builder default sites move with them. The JSON wire values are unchanged, so no serialized payload moves -- only the Java-facing constant names.

• BREAKING: the RDFa structured-data variant is spelled consistently across bindings. One Rust variant previously generated seven different names. Each binding now uses the correct acronym segmentation for its own convention: rdfa (python options.py, elixir, ruby, swift), RDFA (python stub, java, kotlin), Rdfa (csharp, go). Dart keeps rdFa, which is what flutter_rust_bridge itself declares. The wire value "rdfa" is unchanged everywhere.

• BREAKING (python): the type stub declared an enum member the runtime does not have. The .pyi emitted StructuredDataType.RD_FA while the extension declares RDFA, so a type checker accepted the name that raises AttributeError and rejected the one that works. Both now agree on RDFA.

• BREAKING (elixir): VisitResult's payload key matches the NIF struct. %{type: :custom, value: ...} becomes %{type: :custom, custom: ...}, and :error likewise. The NIF struct has always declared custom/error fields, so the previous shape never round-tripped.

• BREAKING (ruby): VisitResult.from_hash reads the real wire key. It read _0; the core enum is adjacently tagged with content = "output", so _0 never matched and the payload was silently discarded in both directions.

Fixed

• <br> inside an inline code span no longer emits a raw newline inside the backticks (#487). <code>A<br>B</code> produced `A\nB`, which CommonMark does not read back as one code span. The span is now split and joined by a real hard break -- `A` + the newline_style marker + `B` -- so the marker sits outside the span, where it is syntax rather than content, and <code> behaves like <b> and <i>, which already emitted hard breaks here. The output is round-trip stable through a CommonMark render; the previous form was not. <kbd> and <samp> had the same defect and are fixed with it.

  Both tiers were wrong and disagreed with each other -- Tier 1 emitted `A \nB`, leaking the two-space marker into the code content -- and both are fixed, so the tiers now agree. A pre-existing Tier-1 bug surfaced on the way: inside a link label the <br> branch ran before the code-span check, trapping two spaces in the first segment.

  Contexts that cannot carry a hard break fold to a single space instead of splitting: headings and table cells. A link label splits, matching what a bare <br> in link text already did.

• A literal line ending inside an inline code span folds to a space. <code>a\nb</code> (a real newline in the source, no <br>) produced `a\nb`. CommonMark gives a line ending inside a code span no hard-break meaning and renders it as a space, so the old output was never round-trip stable. <pre> and fenced blocks are unaffected and keep every newline.

Note

html5ever stays pinned at 0.39.0. 0.40.0's serializer drops the C2 lead byte for every codepoint in U+0080-U+00BF except NBSP (§, ©, °, ±, », ...), emitting invalid UTF-8. In this crate that makes repair_with_html5ever fail its from_utf8 check and silently skip the repair pass on any document containing one of those characters -- it fails safe, but degrades quality invisibly. Fixed upstream in servo/html5ever#784, which is merged but not yet published; this crate will adopt 0.40.x once it is.

chore(release): substitute Swift checksum for 3.12.4

Fixed

• Render <strike> as strikethrough. The Tier-2 inline dispatch listed only del/s, so <strike> fell through to a plain child walk and lost its ~~ markers entirely.

• Merge adjacent inline elements that share a repeated-character delimiter, extending the #483 fix from <em>/<strong> to every other family. <del>A</del><del>B</del> produced ~~A~~~~B~~, which CommonMark reparses as one strikethrough containing A~~~~B; two adjacent code spans produced `AB``, reparsed as one span carrying the literal backticks.<ins>, <mark>, <var>and<dfn>` had the same defect.

• Keep the word separator a whitespace-only inline element stands for, extending the #481 fix to <ins>, <sub>, <sup>, <var>, <dfn>, <abbr> and <q>, each of which joined the words either side.

• Keep <code> </code> as a code span whose content is a space. It was dropped outright, and the delimiter-space padding that an all-spaces body used to get turned one space into three (CommonMark strips one space per end only when the content is not entirely spaces).

• Stop <ins>, <kbd>, <samp>, <var> and <dfn> from emitting their markers inside a code span or fenced block, where ==, a second backtick pair and * are literal content rather than formatting. Every other inline handler already suppressed itself there.

• Close 22 Tier-1/Tier-2 output divergences across the inline elements, found by sweeping both converters over 26 tags. Tier-1 now reproduces <var>/<dfn>, bails on the shapes it cannot (<q>, <mark>, the new delimiter merges, a whitespace-only body), and suppresses <strong>/<em> markers inside a code span as Tier-2 does.

• Treat adjacent duplicate Rust warning flags as equivalent in benchmark provenance checks while preserving timing gates.

• Publish every native NuGet runtime package required by the managed package's runtime graph.

• Upload Dart native archives and checksums required by the generated package downloader.

• Publish Go installer archive aliases and required SHA-256 sidecars.

• Verify the installed Homebrew CLI and FFI versions directly in the registry smoke task.

• Stage original native archives through the shared Zig packager; the 3.12.3 source archive requires separate C FFI libraries.

• Merge adjacent inline emphasis into a single delimiter run, so <i>A</i><i>B</i><i>C</i> renders as *ABC* rather than the *A**B**C* CommonMark reparses as nested emphasis (#483).

• Emit exactly one space for a whitespace-only inline element; A<i> </i>B duplicated it and, inside a paragraph, <p>A<i> </i>B</p> dropped it entirely (#481).

• Drive the musl Node cross-compile through the shared build action, whose per-leg artifact staging replaces the napi artifacts call that @napi-rs/cli 3.9.1 made fail on any single-target matrix leg.

• Keep the visible text of a <tr> nested directly inside a <td>, a shape malformed newsletter HTML produces; the row and its content were dropped silently. The same fix repairs tbody-less tables with implicitly-closed cells, where <table><tr><th>h1<th>h2<tr><td>a<td>b</table> emitted only a one-column header and dropped both the second header and the entire data row (#486).

• Render a data table's nested single-cell table as its own table instead of flattening it into a cell of escaped pipes (#484).

• Apply the WHATWG numeric character reference replacement table, so › decodes to › rather than a raw C1 control character; null, surrogate and out-of-range references now yield U+FFFD (#485).

chore(release): substitute Swift checksum for 3.12.3

Fixed

• Preserve visible images inside font-size: 0 wrappers (#476).
• Recover table cells following malformed Office namespace tags (#477).
• Render data tables inside one-cell layout wrappers as separate Markdown tables (#478).
• Repair nested anchors so both link destinations remain clickable (#479).
• Resolve unpublished native Node packages from the workspace during frozen documentation installs.
• Build prerelease PHP extensions against the local Rust core and committed dependency lockfile.
• Preserve native error codes on typed C# conversion exceptions.
• Prevent panics when nested list visitors shorten earlier output or replace it with multibyte text (#474).
• Generate R and Ruby bindings that pass strict Clippy checks while preserving visitor and conversion behavior.
• Accept explicit nil for optional Ruby conversion fields.
• Use canonical URL-escape enum values in fixtures so Node and WebAssembly suites regenerate completely.
• Point Ruby dependency-update tasks at the native crate and remove the obsolete duplicate Rust workspace.

Changed

• Refactor MCP helpers, image construction, and visitor state to remove three lint suppressions while preserving preprocessing validation order (#466).
• Regenerate all bindings, end-to-end suites, and snippets with Alef 0.85.11.
• Refresh dependency lockfiles across Rust workspaces.

chore(release): substitute Swift checksum for 3.12.2

Fixed

• bullets now applies to layout-table rows (#472). A table with inconsistent column counts and no <th>/<caption> is treated as a layout table and renders each row as a list item — but that renderer hardcoded - and never read options.bullets, so configuring the option had no effect on the markers actually emitted. Surfaced by the reporter of #470, who set bullets to "*+-" in 3.12.0 and still got hyphens.

  The marker now cycles through bullets by nesting depth the same way list items do, so a layout table nested inside a list takes the next marker rather than repeating its parent's. The prefix strip that prevents a doubled-up marker assumed a hyphen as well, and now accepts any configured bullet.

  Default output is unchanged — the default bullets string already starts with -. Tier-1 bails on layout tables, so this is a Tier-2 path with no parity mirror.

chore(release): substitute Swift checksum for 3.12.1

Correctness release covering the four defects reported against 3.12.0. Three are conversion bugs in the core, one extends the hidden-element rule; all four were reported through the Java binding and reproduce identically in every language.

Fixed

• An uppercase void element no longer swallows the rest of the document (#467). The bundled astral-tl parser matches void elements against an all-lowercase table using a tag's raw source bytes, so <META> missed it and was pushed onto the open-element stack as a container: the parent's close tag could not pop it and every following sibling was absorbed as its child. For <head><META ...></head><body> that left <body> a grandchild of <head>, out of reach of the direct-child rescue in handle_head, and the whole document converted to an empty string. The charset attribute in the report was incidental -- the crate has no charset handling, and every HTML5 void element (<BR>, <IMG>, <HR>, <INPUT>, <LINK>, ...) reproduced it. Tier-2 now lowercases void-element tag names during preprocessing; attribute names and values are left byte for byte alone. Tier-1 already lowercased before lookup, so this also closes a tier divergence.

• A nested table inside a cell keeps its row boundaries under br_in_tables (#469). A Markdown cell cannot hold a nested table, so the inner table is flattened into the outer cell with its pipes escaped. Until 3.11.2, br_in_tables: true merely skipped the whole-cell newline fold, letting the inner rows leak out of the cell as raw newlines -- malformed, but a GFM parser could still see two rows. Making that fold unconditional (correctly, for issues #456 and #457: a raw newline between two pipes splits the row across physical lines) collapsed the rows onto one line joined by spaces and erased the boundaries. The fold stays unconditional; the flattened rows are now joined with the literal <br> that br_in_tables already means everywhere else in a cell. A preceding sibling is separated from the nested table too, which previously ran straight into its first pipe (Before\| ID). This restores row boundaries, not table structure -- a real nested GFM table remains impossible and the inner pipes stay escaped.

• Adjacent paragraphs in a layout-table cell are separated (#470). A table with inconsistent column counts and no <th>/<caption> renders each row as a list item, and those cells convert as inline. That suppressed the ordinary block separator while never reaching the table-cell continuation rule, so <p><b>Alice Example</b></p><p><i>Customer Service</i></p> emitted **Alice Example***Customer Service* -- merged words and invalid emphasis. Such cells now follow the settled cell rule from issues #453/#454: a literal <br> under br_in_tables, a single space otherwise. <div> continuations are covered by the same change. Layout rows are list items, so they still do not take table-cell pipe or emphasis escaping. Not a regression -- this predates 3.8.3.

Changed

• font-size: 0 now marks an element as not rendered (#468), joining display: none, visibility: hidden and the hidden attribute. Reported against generated email banners whose marker text reached the Markdown despite being invisible in a browser. Any exact zero length is recognised (0, 0px, 0.0em, .0%, in any casing, with or without !important) and the CSS last-declaration-wins cascade applies as it already does to display.

  This drops content that previous versions emitted. One case is deliberately exempt: the same declaration is the classic inline-block/email spacing hack, where the wrapper kills inter-child whitespace and each child restores a readable size. When a descendant re-declares a non-zero font-size, the subtree is kept. That guard is a one-level-of-inheritance heuristic, not a cascade -- a size restored from a stylesheet is out of reach of a byte-level pass. Tier-1 has no subtree awareness and bails on any font-size: 0, deferring to the tier that can see the descendant.

  Detection remains unconditional, as it has always been for the other three: no option governs it.

Correctness release. A broad pass over converter correctness: defects in the shipped output, plus a run of cases where the Tier-1 fast scanner and the Tier-2 converter disagreed on the same input -- the library picks a tier automatically, so those meant one document could convert two ways.

Test coverage behind it: every one of the 652 CommonMark spec examples is now exercised through a conversion-fixpoint oracle (the exact-match test compares against the spec's own rendering, so it can only run on the 131 examples admitting a single valid form), a Tier-1/Tier-2 differential oracle over the benchmark corpus and a generated document set, and a fuzz target.

Against that fixpoint oracle, 644 of the 652 examples now round-trip unchanged with escaping enabled and 629 with the shipped defaults, up from 607 and 597. Of the 8 that remain, three are inherent to the round trip -- adjacent block quotes, and adjacent lists sharing a bullet, merge under any compliant reparse whatever we emit -- and the other five differ only in the byte spelling of a link destination.

Removed

• htm_conversion_options_update_visitor is gone from the C API. The getter documented a non-null return as caller-owned data, but ConversionOptionsUpdate is only ever constructed through htm_conversion_options_update_from_json, and its visitor field carries a full serde(skip) -- so Deserialize could never populate it and no FFI setter existed. The symbol could only ever return 0. Breaking for C consumers: it disappears from html_to_markdown.h and from the compiled library, so a call that used to yield NULL at runtime is now a link error. Nothing that worked stops working. ConversionOptions.visitor is unaffected -- it carries the same attribute but is genuinely reachable, because htm_options_set_visitor writes it directly, bypassing serde.

Added

• CLI flags for six ConversionOptions fields that the library and the MCP surface already exposed but the CLI hardcoded: --exclude-selectors, --url-escape-style, --max-image-size, --capture-svg, --no-infer-dimensions and --tier-strategy. Each now defaults to the library's own default, so an invocation that omits them is unchanged. The three image flags require --extract-inline-images, which they are inert without.

Performance

• escape_link_label returns Cow<'_, str> and skips its two allocations when the text contains no [ or ], which is the common case for link labels, image alt text and titles. The two-pass design is unchanged -- it exists to avoid an O(n^2) String::insert shape.

Fixed

• Uppercase attribute names no longer discard link destinations and image sources. HTML attribute names are case-insensitive, but the Tier-2 converter matched them byte-for-byte as written, so <a HREF="up.html">link</a> converted to bare link and <img SRC="a.png" ALT="cat"> to ![](<>) -- the destination and the alt text were dropped, not merely reformatted. The Tier-1 fast scanner has always compared attribute names case-insensitively, so these inputs were also a tier disagreement: the same document converted two ways depending on which tier ran. The astral-tl 0.8.0 parser upgrade lowercases attribute keys at parse time, which fixes both.

• Tier-1 and Tier-2 disagreed on GFM autolinks. autolinks defaults to true but was not gated in the Tier-1 router, and the Tier-1 scanner had no autolink branch, so <a href="https://x.com">https://x.com</a> converted to <https://x.com> on Tier-2 and [https://x.com](https://x.com) on Tier-1 -- the library picks a tier automatically, so the same document converted two ways. Tier-1 now implements the autolink form rather than being gated off it, since gating a default-true option would have made the fast path unreachable for ordinary input.

• Tier-1 could return the wrong output for an autolink whose label carried inline markup. Tier-2 tests its autolink predicate against the tag-stripped text, so <a href="https://x.com"><b>https://x.com</b></a> still autolinks there; Tier-1 compared its rendered label (**https://x.com**), never matched, and emitted [**https://x.com**](https://x.com). Tier-1 now bails to Tier-2 on this shape. The bail is guarded by a subsequence precheck so it fires only when an autolink is actually possible: on the benchmark corpus, none of the 889 scheme-href links that carry nested markup trigger it, so decorated links keep the fast path.

• <address>, <search>, <hgroup> and <center> no longer merge into their neighbours. All four are block-level, but they reached a pass-through handler that emits no separator, so <address>foo</address><address>bar</address> produced foobar -- nothing in the output recorded that these were ever distinct blocks. <colgroup>, <col>, <base>, <html> and <body> share the same internal classification and are deliberately unchanged: the first three are table-internal or void metadata, and the last two wrap every document.

• Two block containers in one table cell are separated by one space, not three. The fast scanner emitted a hard line break between them regardless of br_in_tables, and the table-cell finalizer turned it into a three-space run, where the converter emits a single space under the default options.

• Five Tier-1/Tier-2 divergences closed. <blockquote> omitted its trailing blank line in the fast scanner, invisible to every existing test because they all placed the blockquote last; fixing it exposed a <pre> fence stripping one trailing newline where the converter strips all of them. A text node's leading space survived at the start of a bare <span>/<u>, producing a double space across the Google Docs and WordPress fixtures. <address>, <search>, <hgroup> and <center> emitted a block separator the converter does not. Images with a lazy-load src and flattened nested-table pipes now agree as well.

• An HTML comment no longer forces a redundant reparse of the whole document. Custom elements are detected by looking for a hyphen in a tag name, but the scan treated the text inside <!--...--> as a tag name -- !--c-- contains a hyphen -- so any document with any comment was reparsed through the repair path for nothing. On a 200-element document producing byte-identical output, a single comment cost 1.8x. Comments are near-universal in real pages, so most documents were paying it.

• A table nested inside another table's cell no longer destroys the inner cells. The nested table's own row and separator syntax was flattened into the outer cell unescaped, so its bare | characters were read as additional cell boundaries for the outer row. GFM truncates a row to the header's column count, so the inner cells were dropped outright on reparse. The flattened content is now pipe-escaped outside code spans.

• A run of   between two inline elements survives. A whitespace-only text node between inline siblings was collapsed to a single plain space unconditionally. str::trim is Unicode-aware and counts U+00A0 as whitespace, so the run was destroyed on the first conversion, not merely on a round trip. The same collapse also ran without checking whether the output already ended in a space, stacking a real inter-element space against the synthetic one left behind by <style> removal into a literal double space.

• Content written directly inside <table>, outside any row or cell, is no longer dropped. HTML5's "in table" insertion mode foster-parents such content: it moves to just before the table and survives. The parser this crate uses performs no such fixup and the table builder recognised only caption/colgroup/col/thead/tbody/tfoot/tr there, so raw text was silently discarded and stray elements went through a no-op handler -- <table>abc</table> converted to nothing at all.

  It appeared to work whenever a comment happened to sit nearby, but that was coincidence: a separate defect treats !--c-- as a tag name, sees a hyphen, and reroutes any comment-bearing document through the html5ever repair path, which does implement foster parenting. The text survived by accident. That path is now entered deliberately for this shape. Comments themselves are excluded, since HTML5 keeps them as children of the table and nothing is lost.

• Lazy-loaded images resolve to their real address instead of converting to nothing. Lazy-loading libraries leave src empty or holding a 1x1 data: placeholder and put the actual URL in data-src, data-lazy-src, data-original, data-srcset or srcset, so those images came out as ![alt]() or a base64 blob -- effectively invisible on a large share of modern pages. The fallback applies only when src is already empty or a data: URI, so a plain <img src="..."> is byte-identical to before. A populated non-data: src is trusted even when it looks like a placeholder, since some pages carry the real photo there while srcset holds only the lazy-load stand-in.

• A heading inside <summary> or <figcaption> no longer splices its # prefix into unrelated text. Tier-1 records a heading's content offset against whichever buffer is active when the tag opens, and <summary>/<figcaption> accumulate into their own buffer. Only table cells were special-cased, so a heading in a <summary> took a small buffer-relative offset and used it to index the whole document output instead -- inserting heading prefixes into the middle of already-emitted text. Rustdoc's <details><summary><h3 class="code-header"> shape turned Sample into Samp#### #### le. This corrupted adjacent content, not just the heading.

• An unclosed <table> no longer discards its rows. Every element still open at end of input is closed implicitly, but Tier-1's implicit-close path did nothing for <table>, dropping the entire accumulated table -- fully-formed rows included -- where the explicit </table> path rendered it correctly. Text sitting directly inside <table> outside any row or cell is now routed to Tier-2 rather than silently discarded.

• An empty title="" is treated as absent instead of rendered as (url ""). The empty annotation carries no information and no Markdown serializer round-trips it, so converting the re-rendered output produced different Markdown than the first pass. Applies to links, images and graphics alike. A whitespace-only title is still a title; only a genuinely empty attribute changed.

• HTML5 bogus comments render as nothing instead of leaking their text. <?php echo 1; ?> emitted ?php echo 1; ?>, <!bogus> emitted a stray >, and </3> emitted </3>. All three are comment tokens under the tokenizer's tag-open, markup-declaration-open and end-tag-open states, so they render as nothing -- as real <!-- --> comments already did. Identical constructs were rendering differently based only on which tokenizer state they happened to reach.

  Most visibly this cleans up Microsoft Word HTML, whose downlevel-revealed conditional comments (<![if !vml]> … <![endif]>, not wrapped in <!--) were surfacing as literal noise around every image and footnote.

  Real comments, CDATA, and doctypes are stepped over rather than scanned into. That matters for downlevel-hidden conditional comments: <!--[if gte mso 9]> … <![endif]--> is a real comment whose terminator is the --> at the end of <![endif]-->, so treating that <![endif] as bogus would delete the comment's own terminator and swallow the rest of the document. <![CDATA[ is left untouched entirely, since it is only a bogus comment outside foreign content and this pass has no element context to distinguish <svg> interiors.

• strip_hidden_elements no longer treats a non-tag < as a tag, fixing both a content bug and a quadratic-time denial-of-service vector. The hidden-element pre-pass accepted any < whose next byte was not / or !, then scanned forward for the next > anywhere in the document and treated whatever it spanned as a tag. HTML5 only begins a tag name when < is followed by an ASCII letter, so this was wrong in three ways:

  • Visible text was silently deleted. <1div hidden>x</1div> is entirely text, but the pre-pass matched it as a hidden element and removed the whole span including the x. Same for <_div …>, <-div …>, < div …> and any non-ASCII initial.
  • Genuinely hidden content leaked. In <<div hidden>x</div> the span began at the stray first <, so what got removed was <<div hidden> and the x inside the real hidden <div> survived into the output.
  • Conversion was O(n²) in unterminated <. With no > ahead, every candidate < re-scanned to end of input. Converting 40,000 bare < took 1.05 s and 80,000 took 4.2 s; around a megabyte of such input would have taken hours. This is reachable from untrusted pages -- the repo's own fixtures already carry a fallthrough_bare_lt group -- so it was a practical DoS. The same input now converts in roughly linear time; the guarded case dropped from 16.4 s to 0.26 s.

  Output is byte-identical across the whole fixture corpus; the only behaviour changes are the two defect classes above, each now pinned by test.

• A <br> inside a code span or fenced code block no longer injects a newline_style marker into the code. A code context reproduces its content literally, so the marker was not syntax there -- it was a character in the user's code. newline_style="backslash" put a literal \ inside the span (<pre><code>A<br>B</code></pre> emitted A\ on its own line), and the two-space style injected trailing spaces. CommonMark gives a line ending inside a code span no hard-break meaning at all, so the two styles now agree byte for byte there. This is the rule the table-cell branch already applied for the same reason. A <br> between two code spans is an ordinary hard break and is unaffected.

• A <br> at the end of any block no longer leaves a stray \ under newline_style="backslash" (#464). 3.11.6 claimed this was fixed, but the strip ran only inside the paragraph handler, so it covered <p>...<br></p> and nothing else. Every other way an inline run can end still leaked the marker: before a following block of any kind (A<br><p>B, the reporter's follow-up case, plus headings, lists, blockquotes, rules, tables and <div>), at the end of the document (A<br>), at the end of a <div>, list item, blockquote, <section>, <details>, <figure> or <dl>, and through nested containers.

  CommonMark gives a hard line break no meaning at the end of a block, not merely at the end of a <p>. The check now runs wherever a block boundary is actually reached. Handlers that walk their children into a fresh buffer were each an independent instance of the same defect, because str::trim cannot repair a trailing "\\\n" -- it removes the newline and leaves the backslash stranded.

  Worst case fixed: in a <figcaption> the caption is wrapped in emphasis after the marker is appended, so the leftover backslash landed between the text and the closing * and escaped it -- <figure><figcaption>A<br></figcaption></figure> produced *A\*, malformed Markdown rather than a merely visible artifact.

  A <br> that precedes real inline content still emits its break, a leading top-level <br> still opens a line (#112), and newline_style="spaces" output is unchanged -- its leftover marker is invisible trailing whitespace.

• Four cases where the Tier-1 fast scanner produced different Markdown than the Tier-2 converter for the same input. The library picks a tier automatically, so a divergence means the same document could convert two ways depending on which path it qualified for. Tier-2 is authoritative and was correct in all four.

  A custom element (any unknown tag containing -) was treated as block-level, so one appearing inline in flowing text split the surrounding paragraph, list item or blockquote and could leave an orphaned bullet or emphasis marker behind. Unknown elements are inline by default in HTML -- there is no block-level custom element absent a CSS rule this converter does not apply -- so they now pass through inline, as the DOM walker always did.

  Named character references outside Tier-1's hot subset (∉, ∴, ¹, ¶, ™) passed through as literal text instead of decoding. Tier-1 now falls back to the same full WHATWG named-reference table Tier-2 decodes against, rather than a hand-picked subset.

  <strong><strong>x</strong></strong> emitted ****x****, which CommonMark does not parse as strong emphasis at all; redundant same-type nesting now collapses to one marker pair. A trailing whitespace run before a closing inline marker -- most often a decoded   -- stayed inside the markers instead of moving outside them.

  A leading whitespace run inside <strong>/<em> was deleted rather than moved outside the markers, so <p>a<em>&nbsp;x</em></p> lost the space entirely: a*x* where the DOM converter gives a *x*. The trim is still applied to <a> labels, which really are trimmed, and to <code>, which is verbatim.

• The published crate no longer ships two tests that cannot compile. Both read the CommonMark spec fixture from a path outside the crate root, which cargo package does not carry, so cargo test on the packaged crate failed to build. They are excluded from the package and still run from a repository checkout.

• Leading whitespace at the start of a document is stripped, matching every later block. <p>&nbsp;a</p> kept its space while <p>x</p><p>&nbsp;a</p> dropped it, so the same markup converted differently depending only on whether anything preceded it. The converter had no way to tell "start of the real output" from "start of a handler's private scratch buffer" -- every inline wrapper builds its content into a fresh buffer before splicing it in -- so a naive emptiness check silently changed every wrapper whose first child begins with whitespace.

• Block children of a list item stay inside the item. Fenced code blocks and block quotes were emitted without the continuation indentation that keeps them in the item, so they escaped the list entirely on reparse. The indent sums each open ancestor's actual marker width rather than assuming two spaces per level, since ordered markers vary in width (1. against 10.).

• List looseness is detected as the whole-list property it is. One blank line anywhere between items makes a compliant reparse wrap every item in <p>, but detection only looked for a literal <p> and missed div, blockquote, pre, table, hr and dl children and loose nested sublists. Alongside it: a nested list that is an item's sole leading child no longer double-counts the parent marker's width and pushes its content past the four-space indented-code threshold; a block quote following an item's bare leading text is no longer forced onto a blank line, which had made that text round-trip as its own paragraph; a bare <!-- --> between two adjacent same-type lists is preserved, being the one signal that stops them merging; and the bare-marker check now honours the configured bullets instead of hardcoding *, - and ., having missed + from the default cycle.

• A nested list keeps its line break when the text before it ends in whitespace. <li><strong>b </strong><ul><li>sub</li></ul></li> collapsed to - **b** * sub, flattening the sublist onto the parent line so it stopped being a list at all and its content was lost. The "are we already at a bare marker" test was a two-byte suffix check, and a closing **b** plus its trailing space ends in the same two bytes as a real * bullet plus its space. Both tiers were wrong in exactly the same way, so the differential oracle could not see it; the check now requires the whole line to decompose into bare markers.

• Non-ASCII bytes in a link destination are percent-encoded. A raw byte at or above 0x80 is not valid URI syntax under RFC 3986, and compliant renderers encode it when writing an href. Only non-ASCII bytes are touched, so reserved ASCII punctuation in query strings is untouched. Same-document #fragment destinations are exempt: they must byte-match an element id this converter does not generate, and encoding one side of that pair would break the anchor.

• Link-shaped text in image alt text and link labels is escaped. Alt text is parsed as full inline content on reparse, so <img alt="[foo](uri2)"> had its alt silently become a real nested link and lost the destination. Both ends of the pair are escaped, since escaping only the closing bracket leaves the outer [ to be captured by a later ] and the image then fails to form at all. A genuine nested ![alt](src) inside link text is left intact.

• A link or image with no visible text no longer turns its own href into emphasis. Such an element falls back to the href as its label, and that fallback bypassed the text escaper, so a raw * or _ in the URL round-tripped into real emphasis. Two destination-escaping gaps closed with it: a literal backslash before the paren escaping in an unbalanced-parens destination was not itself escaped, and a raw line ending inside an angle-bracket-wrapped destination is not valid CommonMark at all and is now folded to a space.

• The Tier-1 fast scanner matches the Tier-2 converter on every fix above, and on a further run of divergences found by the differential oracle. Because the library selects a tier by input shape, each divergence was a case where one document could convert two ways. Three suppressions were also removed from the oracle's allow-list, so it now generates those shapes freely instead of avoiding them; the four that remain are each documented in place.

• A hard line break inside a link's visible text survives a round trip. A <br> in a link label was collapsed to a space, so converting, rendering back to HTML, and converting again lost the break -- yet a hard break inside link text is perfectly legal CommonMark. Ordinary soft newlines from wrapped source text still collapse to a space, and a break at the very start or end of a label is still dropped, having no line to break to.

• Four more places mistook inline content for a bare list marker. The check was a two-byte suffix test, and a closing **bold** plus its space ends in the same two bytes as a real * bullet plus its space. A block quote after inline text in a list item lost its continuation indent and fell out of the item entirely on reparse, since CommonMark matches containers per line; a fenced code block was glued onto the preceding inline line, where the fence is not a valid opener; a <div> ran straight onto the previous text with no separator at all; and Tier-1's paragraph handler ran the check without first confirming an open list item, so top-level text merely ending in a hyphen and a space lost the blank line before the next paragraph. Several of these also omitted +, the third bullet in the default cycle, so they misbehaved at every third nesting level.

• An unclosed <p> or <div> in a list item no longer swallows the next item. <ul><li><div></li><li>foo</li></ul> converted to - - foo, turning two sibling items into one item holding a nested list, and <ul><li><p>x</li><li>foo</li></ul> converted to - x- foo, running both onto one line so the second stopped being a list item at all. Closing the tag explicitly was already correct, so this hit precisely the shape the HTML5 parsing algorithm resolves with an implied end tag -- ordinary markup, not an edge case. The primary parser nests the following item under the unclosed element; the misparse detector that already re-parses such trees with the spec-compliant fallback only recognized a block nested under an inline ancestor, so a div or p never triggered it. Genuinely nested lists are unaffected.

• Leading whitespace on soft-wrapped continuation lines no longer shrinks on every pass. A run of spaces after a newline in block text collapsed to one space, but CommonMark strips a line's leading whitespace entirely when assembling a paragraph, so a renderer dropped the space that was kept and the next conversion saw one fewer -- the text never stabilized. Such runs now collapse to nothing, which is what a round trip already forces. Whitespace at a text node's own edge is untouched, since that is what keeps adjacent words apart.

• A literal backslash in a link destination is no longer swallowed. Two shapes lost data. A backslash before ASCII punctuation was consumed as a CommonMark escape of that character on reparse, so href="\*" came back as href="*". A backslash at the end of a destination with no title after it merged with the closing parenthesis into an escaped \), so the destination never terminated -- href="x\" reparsed as the literal text [t](x), losing the href and the link structure and leaving raw brackets in the rendered output. Both are now escaped; a trailing backslash followed by a title's space, which is harmless, still is not.

• The Tier-1 fast scanner no longer emits broken output for block children of a list item. A <div> inside an <li> came out with no continuation indent, so its content fell out of the list on reparse; <blockquote>, <table>, <dl>, a <p> continuing existing text and a <pre> as an item's first content were each wrong in their own way. Under the shipped defaults Tier-1 is never reached for these, because metadata extraction and highlight styling both force the DOM converter first -- but with those disabled, all six shapes diverged. Rendering them correctly needs Tier-1 to defer its separator decisions the way the DOM converter does, which also entangles the loose-list heuristic, so the scanner now declines these shapes and falls back instead. No corpus coverage is lost: the new bail never fires across either parity corpus.

• A lone significant character after a <br> is no longer dropped. <p>a<br>&nbsp;</p> kept its non-breaking space, but the same markup with a newline after the <br> lost it -- so whether content survived depended on nothing but whether the source HTML happened to be pretty-printed. A rendered <br> is always followed by a literal newline, which flipped the handler into a branch that discarded the run wholesale. Separately, a <br> inside a heading emitted the two-space hard-break marker, which has no meaning on a single line: a renderer collapses it, so the next conversion saw different bytes. It now emits one space.

• br_in_tables: false is honoured for lists inside a table cell. Both converters emitted a literal <br> between sibling <li> elements in a cell regardless of the option, so the setting silently did nothing for the shape it most often applies to -- a list in a cell, as MediaWiki sidebars produce. This also caused a round-trip instability: once a renderer flattens the list, that same <br> took the ordinary option path on the second pass and collapsed to a space, so the two passes disagreed.

• A non-breaking space between two <br> tags is no longer dropped. The paragraph pre-filter discarded a text node outright when trimming found it empty and both neighbours were empty inline elements -- and trimming is Unicode-aware, so a lone U+00A0 counted as empty even though it is visible content. It surfaced only on a second conversion, because the source spells it   (six ASCII bytes) while a renderer re-serializes it as the literal character. Only genuine ASCII whitespace is dropped there now.

chore(release): substitute Swift checksum for 3.11.6

Re-release of 3.11.5, which never reached any registry: the publish run failed and crates.io still tops out at 3.11.4. Also carries the release-gate fixes below.

Fixed

• <br> runs emit one hard break each, and none trailing a block. A run of consecutive <br> elements collapsed inconsistently, and a <br> immediately before a block boundary added a stray break to the output.

• packages/r/src/Makevars is tracked instead of gitignored. The file is alef-generated and alef-owned, but packages/r/.gitignore discarded it, so alef verify --exit-code -- the "Verify binding freshness" step of CI Rust -- failed on every run. src/Makevars.win stays ignored.

• The Dart e2e before hook installs the pinned flutter_rust_bridge_codegen. It hard-coded 2.12.0 while the project pinned flutter_rust_bridge 2.13.0, so CI Dart aborted on alef's version-disagreement check. [crates.dart] frb_version now declares the pin explicitly next to the hook that has to match it.

Removed

• Dropped a stray Python enum_module from the node and java e2e call overrides; neither emitter reads it.

chore(release): substitute Swift checksum for 3.11.4

Fixed

• alef.toml's [workspace.docs.snippets] timeout_secs was 120s, which also bounds every session's before hook. On a cold checkout the kotlin_android (assembleDebug), wasm (pnpm run build:all) and swift (swift build) sessions could not finish their before build within that window, so their snippets were reclassified unresolved_dependency and reported Unavailable — failing CI's alef snippets check --strict (Failed: 0 but a large Unavailable count) even though no snippet itself was broken. Raised to 900s, matching the precedent in tree-sitter-language-pack's alef.toml.

• The benchmark regression gate no longer fails at random on the CPU the runner happened to draw. htmbench compare compared the whole Provenance struct for equality, so a capture from an Intel Xeon host could not be evaluated against a baseline calibrated on an AMD EPYC host: it aborted with benchmark provenance mismatch before any timing was compared, even though the timings themselves passed every threshold. GitHub's ubuntu-24.04 label spans both vendors and the calibration campaign is workflow_dispatch-only, so which host each side drew was a coin flip. cpu_model and cpu_count are now excluded from the provenance contract; every other field — rustc, Cargo, profile, build flags, core features, measurement mode, tier and visitor selection, iteration/warmup settings, runner image and class — still hard-fails on drift. A differing CPU is reported instead as a host mismatch, and the new off-by-default --allow-host-mismatch flag (passed only by the CI regression job) downgrades timing violations to advisory on hardware the baseline was never calibrated on. Thresholds are unchanged and the baseline was not re-cut: a regression measured on the calibrated CPU still fails the run.

• The FFI Symbols CI gate is green again. It was failing on two independent findings.

  The htm_register_html_visitor allowlist entry is retired. It claimed "visitor registration never landed in the FFI crate", which is no longer true: registration landed as the vtable API htm_visitor_create / htm_options_set_visitor / htm_visitor_free, and the alef 0.62.6 regen (4765a4139) replaced the last phantom caller — a Java Panama SymbolLookup.find(...) in NativeLib.java — with lookups of those real symbols. The checker reported the entry as orphaned rather than resolved only because it matches on exact symbol names and the replacement uses different ones. The C# visitor surface reaches the same exports through NativeMethods.cs and HtmlToMarkdownConverter.Convert, and all 49 tests in e2e/csharp/tests/VisitorTests.cs pass against the built native library, so the public IHtmlVisitor / HtmlVisitorBridge API is wired end to end.

  htm_node_type_from_json is allowlisted, replacing it. The alef 0.62.9 regen (dc27e0560) re-added a C# P/Invoke for it, but NodeType is a fieldless Copy enum: it crosses the C ABI as int32_t, so the FFI exports htm_node_type_from_i32 / htm_node_type_from_str and no handle-returning from_json. Nothing calls NodeTypeFromJson, so the declaration is latent rather than a live crash. This is a re-regression — the same symbol was allowlisted and retired once before in 555a29d20. Fixed upstream in alef's C# backend, which now skips scalar-crossing named types when emitting handle-lifecycle P/Invokes; the entry comes out with the first regen on an alef release carrying that fix.

• A failed per-language artifact build no longer aborts the release. In v3.11.3 four Build PHP extension (... windows-x86_64) legs failed and nothing else did, yet the GitHub release was never promoted out of draft, never finalized and never announced, and the Homebrew bottles, cargo-binstall verification, Packagist trigger and asset audit never ran — 3.11.3 reached every language registry but its release page stayed a draft.

  Two GitHub Actions behaviours caused it, and the publish workflow now accounts for both. A failure propagates down the entire needs chain, so a job's implicit success() gate is false even when its own direct needs succeeded; and the propagated failure also poisons the value of needs.<job>.result, so upload-php-pie-release reported failure to downstream jobs despite concluding success — which is why always() plus !contains(needs.*.result, 'failure') still skipped verify-assets, release-finalize and announce-discord.

  The release spine (promote-release → release-finalize → announce-discord, plus verify-binstall and the Homebrew bottle jobs) now gates only on jobs whose whole ancestry is release-blocking: version validation, crates.io, and the CLI and C FFI assets. Per-language artifact jobs stay in needs for ordering — the draft still flips only after every asset upload has settled — but their results no longer appear in any gate. promote-release publishes a promoted output for downstream jobs to gate on, because job outputs carry no failure poison.

Added

• A Report release outcome job closes the workflow. It reads the run's real job conclusions from the API and writes a job summary stating whether the tag shipped and naming every artifact that is missing, then fails the run if anything failed. A release that ships without one language's binary is now red and explicitly labelled incomplete rather than silently green.

Changed

• Verify release assets is a reporting gate rather than a release gate. It runs on every real tag and no longer guards itself with !contains(needs.*.result, 'failure'), which had skipped the asset audit in exactly the situation the audit exists for. Nothing in the release spine depends on its result.

Fixed

• Leading normalized whitespace at the start of a paragraph is no longer emitted before an image, preventing CommonMark from interpreting the image as an indented code block (#460).

• The Swift crate compiles again. Codegen emitted a bare EnumName::Variant path for data-carrying variants when converting a Swift string back into a Rust enum, which rustc rejects with E0533: expected value, found struct variant; the regenerated crate routes those through per-enum string conversion helpers instead.

• The e2e freshness gate no longer fails on formatting it cannot produce. It installs Elixir, so alef's mix format pass runs there as it does locally — without it the job emitted unformatted .exs and reported the difference as fixture staleness.

• The crates.io skip guard reads a real output again. The publish workflow asked check-registry for an extra-packages key (cli_exists), but a composite action propagates only the outputs it declares, so that key arrived as an empty string and the derived all_exist could never be true. The guard has therefore never once skipped an already-published version. It now reads the action's declared all-exist output.

Changed

• packages/java/pom.xml is alef-owned and regenerated. It had drifted out of alef's ownership since roughly alef 0.60.x for want of a provenance marker, so this release lands the accumulated template changes at once: the file is reindented to four spaces, gains <excludes> / <sourceFileIncludes> blocks, and moves checkstyle to 13.11.0 and jackson-databind / jackson-datatype-jdk8 to 2.22.2. Those versions are alef's pinned template defaults, not html-to-markdown-specific choices.

• All Rust dependencies taken to their latest versions (cargo upgrade --incompatible followed by cargo update): rmcp / rmcp-macros 3.1.2 to 3.1.4 plus twelve transitive bumps. Fourteen packages changed, none downgraded.

• alef pinned to 0.62.8.

• The benchmark harness now records nine timing samples with median and median absolute deviation, captures runner and toolchain provenance, and supports reviewed fixture-specific noise floors without changing the existing percentage regression thresholds (#461, #462).

• Java's VisitResult is now a plain sealed interface. Its Jackson @JsonSerialize / @JsonDeserialize annotations and the nested serializer and deserializer classes are gone; the visitor bridge marshals the type directly and never routed it through Jackson.

Removed

• The unused Java visitor classes IHtmlVisitor, HtmlVisitorAdapter and HtmlVisitorBridge. They shipped alongside the live HtmlVisitor, VisitorBridge and VisitorHandle surface but nothing in the binding referenced them, so an implementation of IHtmlVisitor was never invoked. Implement HtmlVisitor instead.

Fixed

• The R package now builds against the vendored core crate instead of failing to resolve it. configure stripped the path = ... clause from src/rust/Cargo.toml and wrote a cargo source replacement to src/rust/.cargo/config.toml, but cargo reads .cargo/config.toml only from the working directory and its ancestors, and Makevars.in runs cargo from packages/r/src — so src/rust/.cargo is a descendant and that config was never read on any build. With the path clause gone the dependency fell through to crates.io, which did not have the workspace version. The path is now rewritten to point at the vendored copy, which needs no cargo config, no .cargo-checksum.json, and no complete vendor tree.

• Newlines inside a table cell no longer leak into the rendered row when br_in_tables is enabled (#456, #457). The whole-cell newline backstop was gated on !br_in_tables, so enabling br_in_tables disabled the last-resort guarantee that a raw newline never reaches a cell. Two consequences: a <pre> inside a cell now renders inline, dropping its fence, indentation and language info string, matching how headings and list items already render in cells; and under WhitespaceMode::Strict a newline inside a cell now folds to a single space. Every other whitespace byte is still preserved exactly under Strict, and text outside table cells is unaffected.

• The Tier-1 fast path now honours br_in_tables inside table cells. It previously emitted a sentinel that always expanded to three spaces, ignoring the option, so a document routed through Tier-1 could render <br> in a cell differently from the same document routed through Tier-2. Tier-1 also folds a text node's trailing newline the way Tier-2 does, fixing cells that were double-spaced against Tier-2 when the source HTML was pretty-printed across several lines.

• A literal backslash in HTML prose is no longer silently lost when the Markdown is read back (#458). CommonMark consumes a backslash that precedes ASCII punctuation, so emitting 3\*4 from <p>3\*4</p> produced Markdown that reparsed as 3*4 — the source character was gone. Such a backslash is now doubled, and so is one that sits immediately before a line ending (where CommonMark would read it as a hard line break) or at the end of a text run (where whatever the emitter appends next would become its escape target). This changes output under default options: any document whose prose contains a backslash in one of those three positions gains a second backslash there. A backslash before anything else is already literal and is still emitted bare, so Windows paths such as C:\Users\Alice are unchanged. Code spans, code blocks and link titles are also unaffected — the first two are verbatim by design and the third already escaped backslashes through its own rule. The escape is deliberately not gated behind escape_misc or escape_ascii, because it preserves a character the source actually contained rather than neutralising Markdown syntax the way those flags do.

Swift Package Manager

Add to your Package.swift:

.package(url: "https://github.com/xberg-io/html-to-markdown", from: "3.10.6")

The Swift binding is distributed as a pre-built artifact bundle. No Rust toolchain required.

Artifact: HtmlToMarkdown-rs.artifactbundle.zip
Checksum: 63dab7ab85743b5527de0149cb369029c67f1b55ad69897de09a3611186e4d3d

Zig

Add to your build.zig.zon:

.dependencies = .{
    .html-to-markdown-rs-zig = .{\n        .url = \"https://github.com/xberg-io/html-to-markdown/releases/download/v3.10.6/html-to-markdown-rs-zig-v3.10.6.tar.gz\",\n        .hash = \"html_to_markdown_rs-3.10.6-QtXyW946AQBULKaX63V4lYQJddpr-rfMxGrlWJ-1NuKp\",\n    },\n},\n```\n

Fixed

• Node.js: the linux-x64-musl and linux-arm64-musl packages really are published now. 3.10.5 added them, but both cross-compiles failed to link (cannot find libgcc_s.so.1) and, because the npm publish job requires every matrix leg, no Node package reached the registry at all. The build action exported CC/CARGO_TARGET_*_LINKER pointing at musl-gcc, and cargo-zigbuild only sets those when they are unset, so the zig cross-compile was silently replaced by a host-arch musl-gcc that cannot produce a musl cdylib. The musl legs now opt out of that export.

Added

• CI: the musl Node cross-compiles are built on every core/node change instead of only at publish time, and the job fails if a platform package ends up without a native module.

Fixed

• Node.js: the linux-x64-musl and linux-arm64-musl packages are now built and published. They were advertised in the main package's optionalDependencies but never produced, so Alpine and other musl installs silently fell back to no native binding, and pnpm install --frozen-lockfile could not resolve them.
• Ruby: the gem no longer publishes its generated types into the global Object namespace, which collided with unrelated libraries (notably the parser gem's Parser constant). Generated types now stay namespaced under HtmlToMarkdown (tree-sitter-language-pack issue #173).
• Documentation: every code snippet in the READMEs, the docs site, and the coding-agent plugin references was executed against the real API and corrected. The Rust README's metadata and custom visitor examples did not compile, the Rust API reference showed Result<_, Error> instead of Result<_, ConversionError>, the docs site shipped 102 empty language tabs across five pages, and several bindings' snippets referenced helpers that no longer exist.

Fixed

• Node.js: named ESM imports such as import { convert } from "@xberg-io/html-to-markdown" now resolve. The napi-generated index.js ended with module.exports = nativeBinding, which Node's ESM↔CJS interop (cjs-module-lexer) cannot statically analyze, so named imports threw SyntaxError: The requested module ... does not provide an export named 'convert'. The build now appends explicit module.exports.<name> = nativeBinding.<name> re-exports for every public runtime export; require() is unaffected (#450).

Fixed

• The Swift package now builds under Xcode/XCBuild, not just swift build. The RustBridgeC target was header-only, so XCBuild failed to link (RustBridgeC.o was never emitted) for every iOS/macOS consumer of the published SwiftPM package. It now ships a translation unit with an anchor symbol so the object is always produced (#449).

Changed

• The PHP binding sources now live in the html-to-markdown-php crate alongside the other in-crate bindings; the standalone packages/php layout has been removed. Composer consumers are unaffected.

Added

• cargo binstall html-to-markdown-cli support (#448) — prebuilt CLI binaries can now be installed directly from GitHub Releases without compiling from source. Adds [package.metadata.binstall] to the CLI crate plus a release-time verify-binstall CI job that installs via cargo binstall and smoke-tests the binary.

Changed

• Updated dependencies.

Fixed

• The Android AAR (io.xberg:html-to-markdown-android) now bundles its JNI native libraries. Previously the published AAR contained no .so files, so every consumer crashed at runtime with UnsatisfiedLinkError: library "libhtm_jni.so" not found (#446). The publish workflow built the wrong crate (the C-FFI html-to-markdown-ffi) and uploaded it from a path the build action never wrote, staging nothing. It now builds the JNI crate (html-to-markdown-rs-jni → libhtm_jni.so) and stages it for every ABI, and a regenerated Gradle guard (alef 0.48.16) fails the build if a correctly-named lib*_jni.so is ever missing.

Added

• The core library now emits structured tracing spans and events as a first-class observability surface: an html_to_markdown::convert span (input_len, output_format, wrap, extract_metadata, extract_images, tier_strategy fields) wraps every conversion, with DEBUG events at parse/walk/render stage boundaries and WARN/ERROR events on recovered or fatal failures. The library never installs a subscriber — attach one in your application to observe it. The CLI now initializes a tracing-subscriber (respecting RUST_LOG, with --debug raising the default level) and routes all diagnostics through tracing instead of raw stdout/stderr writes.

Changed

• Android AAR now ships four ABIs (arm64-v8a, x86_64, armeabi-v7a, x86).
• Upgraded dependencies to latest, including base64 0.23 and rmcp 3.0.1.

Changed

• Upgraded the MCP server to rmcp 3.0 (MCP 2026-07-28 specification). The server now advertises protocol version 2026-07-28 and negotiates down for older clients, so existing integrations keep working. Minimum supported Rust version is now 1.88.

Added

• Structured tool output (SEP-2106): convert_html (with json:true) and extract_metadata now return structuredContent alongside the text JSON, so clients can consume the result as data.
• Cache hints (SEP-2549) on the static prompt/resource catalogs (prompts/list, resources/list, resources/read): ttlMs of one hour with a public cache scope.

Fixed

• Java (Maven Central) and C# (NuGet) publishing, which failed in 3.9.1. Regenerated all language bindings on alef 0.48.4: the generated pom's Maven enforcer floor no longer exceeds the CI runner's Maven version, and the C# package now renders runtime.json (from the newly generated runtime.json.template) before dotnet pack via the xberg-io/actions/render-runtime-json step.

Changed

• Upgrade dependencies to their latest incompatible versions.

Changed

• Refine the depth-limit warning (#434): the DepthLimitExceeded message now reports the effective limit value, and the warning is emitted exactly once when a deeply-nested DOM is truncated. Thanks @br411 (#428).
• Regenerate all language bindings on alef 0.48.2.
• Update dependencies to their latest compatible versions.

Removed

• Remove unused Java PMD ruleset and stale linter configuration.

Added

• Configurable traversal-depth ceiling (#434): callers may now raise the recursion limit above the conservative native default (64) by setting an explicit max_depth, honored up to an internal backstop of 1024. Deeply-nested email HTML that previously lost content past depth 64 now converts. When the limit does truncate a subtree, a DepthLimitExceeded warning is surfaced instead of the content being dropped silently.

Fixed

• <br> in table cells with br_in_tables (#429): a <br> inside a table cell now emits a literal <br> (valid single-line GFM) instead of a physical newline that broke the row.
• Newline-only inline span separator (#430): in normalized whitespace mode a <span> whose sole content is a newline now collapses to a single separating space instead of being dropped, so adjacent inline text no longer glues together.
• Paragraph after a table inside a blockquote (#431): the span newline-pop no longer crosses a table-row boundary, so a following paragraph is not glued onto the delimiter row.
• Intentional hard break inside a span (#432): the span newline-pop no longer eats a <br> hard break ( \n / \\\n), preserving the line break.
• keep_inline_images_in inside layout-table cells (#433): images inside a td/th listed in keep_inline_images_in now stay as markdown when a Tier-2 layout table converts cells as inline, instead of reducing to alt text.

Changed

• Regenerate all bindings with alef 0.37.0.
• Update dependencies across language packages.

Fixed

• Java visitor API (#426): ConversionOptions.builder().withVisitor(...) now works. The visitor upcall FunctionDescriptors were generated with a JAVA_LONG return layout while the handleVisit* bridge methods return int, so the Java Linker rejected every stub with IllegalArgumentException: Wrong method handle type: (MemorySegment×5)int — even a no-op visitor threw before any callback ran. Fixed upstream in the Alef generator (0.34.4); the descriptor return layout is now JAVA_INT.

Changed

• Regenerate all bindings with alef 0.34.4.
• Formatting is now poly-only: removed the alef:format, ruby:format, and csharp:format tasks (which invoked alef fmt); task format / poly fmt --fix . is the single formatter.

Stable release promoting 3.8.0-rc.2 (fully published). Version-only bump synced across all manifests.

Changed

• Regenerate all bindings with alef 0.29.3.

Changed

• Rebrand Kreuzberg → Xberg across every published package identity. The Node binding now ships as @xberg-io/html-to-markdown (the NAPI-RS crate itself — the separate -node package and the TypeScript wrapper under packages/typescript/ are removed) with platform packages @xberg-io/html-to-markdown-<platform>; WASM and CLI move to @xberg-io/html-to-markdown-wasm and @xberg-io/html-to-markdown-cli. Java/Kotlin Maven coordinates and namespace move to io.xberg (io.xberg:html-to-markdown[-android], JNI symbols Java_io_xberg_android_…), and the C# NuGet id to XbergIo.HtmlToMarkdown. The GitHub org (github.com/xberg-io), Homebrew tap (xberg-io/homebrew-tap), publisher GitHub App, sponsors links, and all docs/badges follow. The legal entity name Kreuzberg, Inc. is unchanged.

Fixed

• Swift publish now creates the release/swift/<version> branch carrying the substituted XCFramework checksum. The alef-generated Swift e2e/test-app pins .package(url: …, branch: "release/swift/<version>"), but the publish workflow only force-moved the v<version> tag and never created that branch, so SwiftPM could not resolve the package. The checksummed commit is now also pushed to refs/heads/release/swift/<version>. (.github/workflows/publish.yaml)
• test(test_apps/go): extract the module version with $NF instead of $2. The smoke harness' download_ffi.sh read the version from $2, which only holds in the block require (…) go.mod form; the inline require <path> <version> form (emitted by the v3.7.2 regen) shifts the version to $NF, so the script built a malformed module-cache path and failed with "Binding directory not found". This is test-harness only — the published Go package is unaffected.

Fixed

• chore(deps): bump alef.toml.alef_version to 0.26.6 and regenerate every binding. Fixes the dart wrapper crate failing to build under cargo build --no-default-features: alef 0.26.x had regressed the 0.25.33 fix and re-emitted #[cfg(feature = ...)] on the generated lib.rs mirror struct / opaque-wrapper declarations, their From conversions, and from_json bridge fns, while frb_generated.rs references those types/functions unconditionally (E0425: cannot find type VisitorHandle / create_html_metadata_from_json). alef 0.26.6 keeps those declarations unconditional again. Verified: the regenerated dart crate compiles under --no-default-features, default, and --all-features. (alef 0.26.6)
• ci(publish): the Homebrew Swift artifactbundle no longer forces kreuzberg/openssl-vendored. The shared build-swift-artifactbundle action hardcoded that feature for its Linux (cargo-zigbuild) targets, but it only exists in the kreuzberg core swift crate — so html-to-markdown's swift bundle build failed (the package '…' does not contain this feature), which cascaded to skip release-finalize (and with it the packages/go/vX.Y.Z Go module tag). The action now takes a linux-features input (left empty here). (shared xberg-io/actions/build-swift-artifactbundle)

Added

• feat(mcp): expand the MCP server to full API parity with typed, discoverable options and complete tool annotations. The convert_html tool now accepts a typed config object covering every settable ConversionOptions field (heading/list/escaping/whitespace/wrapping, preprocessing, image extraction, output format, tier strategy, …) instead of an opaque untyped JSON blob, so MCP clients discover all options through the tool's generated inputSchema; enum options are accepted as case-insensitive strings parsed by the core parsers. A new extract_metadata tool returns structured <head>/<meta> metadata (title, Open Graph, Twitter Card, JSON-LD/microdata, headers, links, images) as JSON. Both tools carry the full MCP annotation set (title, read_only_hint=true, idempotent_hint=true, destructive_hint=false, open_world_hint=false). The typed ConvertConfig mirror is implemented MCP-side (no changes to the alef-tracked core option types) and guarded by a drift test that fails if a core option is added without being mirrored. The mcp feature now implies metadata. (crates/html-to-markdown/src/mcp/)
• feat(mcp): add prompts, resources, and completions capabilities. Beyond tools, the server now advertises three more MCP capabilities: prompts — ready-made workflow templates (convert_to_markdown, extract_main_content, inspect_metadata) that drive the tools, with arguments; resources — htmltomarkdown://options-schema (the JSON Schema of every conversion option) and htmltomarkdown://output-formats (the markdown/djot/plain guide); and completions — argument autocompletion for prompt arguments (e.g. output_format → markdown/djot/plain). (crates/html-to-markdown/src/mcp/catalog.rs)

Changed

• chore(deps): re-pin alef.toml.alef_version to 0.25.60 and regenerate every binding, e2e suite, README, and API doc. Folds in the 0.25.59–0.25.60 generator fixes: the R/extendr by-reference DTO rework now emits a non-optional Named param following an optional param as &T (passed by reference via an owned name_core binding) instead of the non-compiling Nullable<&T>::into_option() path; Kotlin/Kotlin-Android content-union text() accessors reference the actual data-class payload property (value) instead of the non-existent field0; generated binding rustdoc de-links core intra-doc references (e.g. [`Error::LanguageNotFound`]) to plain code spans so rustdoc -D rustdoc::broken-intra-doc-links passes; and sync-versions now runs the same format_generated pass as alef all, so version-bumped manifests (package.json, composer.json, Package.swift) are byte-identical to the generate path and no longer trip freshness gates. (alef 0.25.60)

Fixed

• chore(precommit): scope the v2.3.0 strict doc/format/lint hooks away from the generated trees. The canonical-hookset bump (v2.3.0, commit 8a5203b7d) enabled several strict hooks that ran against alef-generated code and failed on it. All per-language code under packages/<lang>/, e2e/, and test_apps/ is generated and ships as alef emits it, so each hook now carries the same generated-tree exclusion the other formatters already use: yard-coverage excludes packages/ruby/ (its native.rb holds undocumentable Sorbet-sig RBI defs); air-check/air-format exclude packages/ (alef formats R with styler, not air); palantir-java-format excludes packages/, e2e/, test_apps/, and the vendored .mvn/ wrapper. The lintr hook runs lintr::lint_dir(".") and ignores pre-commit file scoping, so its exclusion lives in a new root .lintr (exclusions: list("e2e", "packages", "test_apps")); tsc-typecheck runs tsc --noEmit from the repo root, so a root tsconfig.json scopes type-checking to packages/typescript/src. .yardoc/ (yard's cache side-effect) is gitignored. (.pre-commit-config.yaml, .lintr, tsconfig.json, .gitignore)
• chore(precommit): exclude alef-canonical generated files from the formatters that diverge from alef's own output. alef 0.25.58 made alef verify output-sensitive and the v2.3.0 hookset added alef-docs-fresh (which runs alef verify), so any prek formatter that rewrites a generated file differently than alef emits it now breaks verify. Fourteen generated files hit this because the hooks' pinned tools differ from alef's: ruff/ruff-format (line-wrapping generated Python), pyproject-fmt (alef runs no pyproject-fmt pass), oxfmt (alef formats composer.json via npm oxfmt; the hook uses the oxc binary with a different style), shfmt (generated download_ffi.sh/install.sh/gradlew), cargo-sort (the workspace-excluded R and Elixir NIF Cargo.toml), and end-of-file-fixer (the Dart frb_generated.dart and test_apps __init__.py). Each now carries the generated-tree exclusion the other tools already use, so the files ship exactly as alef emits them and alef verify stays clean. (.pre-commit-config.yaml)

Changed

• chore(deps): re-pin alef.toml.alef_version to 0.25.58 and regenerate every binding, e2e suite, README, and API doc. Folds in the 0.25.55–0.25.58 generator fixes that apply here: the generated Go cmd/download_ffi/main.go tool now carries the standard auto-generated by alef marker so golangci-lint's generated: lax skips it (0.25.x had dropped its //go:build ignore guard, exposing inherent-to-a-downloader gosec/errcheck findings); the generate/all up-to-date skip now also compares against on-disk output (not just the side cache), so out-of-band drift (a git restore, a hand-edit, an interrupted write) is regenerated rather than silently retained; extract OR-merges cfg gates for same-named types with disjoint gates; R/extendr forwards cfg-gated core features into the generated crate's [features] table so it builds under -D warnings. The visible churn is the generator's .d.ts/TS-bridge reformatting (tabs→2-space, double→single quotes). Verified locally: alef verify is clean and the 3.6.20 bump is synced across all manifests. (alef 0.25.58)

Fixed

• test_apps(php): install the PHP extension via PIE's pkg:version syntax. Both generated PHP test_app installers (test_apps/php/install.sh, test_apps/php_ext/run_tests.sh) ran pie install --version "$VERSION" <pkg>, but PIE parses --version/-V as "print PIE's own version" and exits without installing — the pinned extension version was never fetched, so the registry-mode PHP smoke validated whatever stale build happened to be present (or nothing). Use pie install "<pkg>:$VERSION" so the targeted release is actually installed. (alef 0.25.54)
• ci(publish): unblock the npm/Node publish under pnpm 11.8.0. The node-bindings job runs setup-node-workspace (which installs with --no-frozen-lockfile) and then build-node-napi, whose own pnpm install --filter re-enforces CI's default frozen-lockfile. The napi platform optionalDependencies are pinned to the not-yet-published release version, so they cannot be in the lockfile — pnpm 11.6.0 treated the redundant install as a no-op, but the 11.8.0 bump made it fail (ERR_PNPM_OUTDATED_LOCKFILE), dropping every Node build and the npm publish. Pass install-deps: false so the already-installed workspace is reused. (.github/workflows/publish.yaml)
• ci(homebrew): drop the macOS-Intel CLI block from the formula template. The CLI matrix no longer builds x86_64-apple-darwin (Apple Silicon only), but scripts/publish/html-to-markdown.rb.tmpl + homebrew.json still referenced cli-x86_64-apple-darwin.tar.gz, so "Update Homebrew formulas" failed (no assets match the file pattern) and the tap stayed on the prior version. Remove the macOS on_intel block; macOS is now arm-only. (libhtml-to-markdown is unchanged — the C FFI still ships an x86_64-apple-darwin archive.)

Changed

• chore(deps): re-pin alef.toml.alef_version to 0.25.54 and regenerate every binding, e2e suite, README, and API doc. Folds in the 0.25.51–0.25.54 generator fixes: the PHP PIE pkg:version install fix above; Go — unit/newtype-tuple enum constants emit serde wire values, a parameter named result no longer collides with the codegen variable, and Option<&[u8]> returns generate correctly; R/extendr — cfg-variant dedup, registration entries drop the stray #[cfg(...)], and opaque-method/Option/Vec/error returns convert properly; C# — corrected host-capsule native method name; Swift — Package.swift dependency argument order and e2e harness_extras product override; test_apps runner — declared [crates.e2e.env] vars are exported to the run command. Verified locally: both PIE fixes are present in the regenerated test_apps and the 3.6.19 bump is synced across all manifests.
• chore(precommit): scope oxfmt/oxlint away from generated e2e/+test_apps/. alef has no e2e/test_apps JS/TS formatter (alef.toml [crates.e2e.format] covers go/python/rust/c only), so oxfmt was the lone tool reformatting generated test JS, producing churn on every regenerate. Add the ^(e2e/|test_apps/) exclude that go-fmt, ruff-format, and golangci-lint already carry; generated test JS now ships as alef emits it, matching e2e/ruby, e2e/php, etc. (.pre-commit-config.yaml)

Fixed

• ci(publish): unbreak Python wheels on every platform. The shared build-python-wheels action source-built libheif 1.23.0 (with libde265/x265 codec headers) for all consumers because kreuzberg links libheif-sys. html-to-markdown does not use libheif, but inherited the build — which fails on the manylinux2014 (CentOS 7 EOL) base whose yum repos no longer carry libde265-devel/x265-devel (Error: Not tolerating missing names on install). The action now gates the libheif build behind an opt-in build-libheif input (default off); h2m no longer builds it, so all Python wheels build again. (xberg-io/actions@v1)
• ci(publish): re-exclude php8.5 + macos-arm64, restoring PHP publishing. v3.6.17 tried to build the php8.5 Apple-Silicon PIE asset on the macos-14 runner (#333), but shivammathur/setup-php cannot provision PHP 8.5 on arm64 on any macOS runner (the install leaves empty paths — sed: : No such file, /php.ini: No such file). That failing cell skipped upload-php-pie-release, dropping every PHP PIE asset (a v3.6.15-class regression). Restoring the exclusion republishes the PHP extension for all supported targets (PHP 8.2–8.5 on linux/macos-x86_64/windows, plus arm64-darwin for 8.2–8.4). #333 stays open pending an upstream php@8.5 arm64 formula. (.github/workflows/publish.yaml)

Changed

• chore(deps): re-pin alef.toml.alef_version to 0.25.50 and regenerate every binding, e2e suite, README, and API doc. Folds in the 0.25.50 cross-language visitor-codegen fixes that turn the chronically-red e2e visitor suites green: Node — the bridge now reads the externally-tagged { Custom: ... }/{ Error: ... } payload key (was lowercased to custom/error, yielding [object Object]); Ruby — visitor callbacks take named params and interpolate {placeholder} templates; PHP — bare-string returns map to Custom for multi-payload result enums; Elixir — unit-variant atoms match the snake_case wire name (:skip no longer leaks as literal "Skip"); Swift — visitBlockquote's depth is UInt, so the override satisfies the protocol. Verified locally: every language e2e suite passes and alef verify is clean.

Fixed

• ci(publish): re-exclude php8.5 + macos-arm64 from the PHP extension matrix, restoring PHP publishing. v3.6.15 removed this exclusion to chase the Apple-Silicon PIE asset for #333, but shivammathur/setup-php still cannot provision PHP 8.5 on macos-arm64 — the homebrew tap has no php@8.5 arm64 formula, so the cell fails at the setup step with "Could not setup PHP 8.5". Because upload-php-pie-release does not run when needs.php-extension.result == 'failure', that single failing cell dropped every PHP PIE asset from the v3.6.15 release (a regression from v3.6.14's full set). Restoring the exclusion returns the matrix to all-green and republishes the PHP extension for every supported target (PHP 8.2–8.5 on linux/macos-x86_64/windows, plus arm64-darwin for 8.2–8.4). #333 stays open until upstream ships a php@8.5 arm64 formula. (.github/workflows/publish.yaml)
• ci(publish): re-publish the Ruby gems missing from v3.6.15. The v3.6.15 run skipped publish-rubygems because the Build Ruby gem (windows-x64) cell hung ~3h on setup-rust and was cancelled, failing the needs.ruby-gem.result == 'success' gate. This is a transient runner fault, not a code defect; cutting v3.6.16 re-runs the publish so the gems ship.

Fixed

• ci(publish): attempted to build the PHP 8.5 + macOS arm64 (Apple Silicon) PIE extension (#333) — ineffective, reverted in 3.6.16. Removed the build-matrix exclusion for php8.5 on macos-latest, but shivammathur/setup-php cannot install PHP 8.5 on arm64 (no php@8.5 arm64 homebrew formula), so the cell failed at setup and — because upload-php-pie-release skips on a failed matrix — dropped all PHP PIE assets from this release. See the 3.6.16 entry. (.github/workflows/publish.yaml)
• docs(php): use the native HtmlToMarkdownApi class in all PHP examples. The README quick-start, API reference, and docs snippets used the HtmlToMarkdown userland wrapper, which is only autoloaded via Composer's PSR-4 and is absent on the PIE install path (extension-only) — so HtmlToMarkdown::convert() raised "Class not found" for users who installed via pie. Examples now call HtmlToMarkdownApi::convert(), the native class registered by the extension itself, which works on both the PIE and Composer install paths (#415). (readme_templates/partials/, docs/snippets/php/, docs/language-guides.md)

Changed

• chore(deps): bump alef.toml.alef_version to 0.25.44 (was 0.25.40) and regenerate every binding, e2e suite, README, and API doc. Folds in the 0.25.41–0.25.44 cross-language generator fixes. Verified locally: alef verify is clean, cargo check --workspace --all-features compiles, and prek run --all-files (including the alef freshness hook) passes.

Fixed

• chore(deps): bump alef.toml.alef_version to 0.25.40 (was 0.25.36) and regenerate every binding. Advances the pin past the [Unreleased] 0.25.33 note to a tagged, published alef revision and folds in the 0.25.34–0.25.40 cross-language fixes. Binding-visible changes: Java drops the throwing UnsupportedOperationException DTO/enum-method stubs (NodeContext.withOwnedAttributes/intoOwned, ConversionOptions.defaultInstance, PreprocessingOptions.defaultInstance) — there is no JNI symbol for these yet, so the stubs compiled but threw at runtime; absence is safer than a misleading throw until DTO marshaling lands (boxed-Boolean serde defaults also restored). Swift emits a matching pub fn visitor_handle_noop definition for the bridge no-op declaration so the swift rust crate compiles (was E0425 under 0.25.36's decl-without-def), alongside the upstream streaming-owner declaration rework. Node (NAPI) map-returning functions now convert borrowed maps to owned HashMap instead of returning them bare (fixes a would-be E0308 from the new DTO-method emission). Python (pyo3) drops a redundant # type: ignore[arg-type] on the visitor assignment that mypy --strict (warn_unused_ignores) rejected, and None-guards the coercion comprehension for optional Vec<enum> fields. Verified locally: task alef:generate is fresh (alef verify), every workspace binding crate compiles, and prek run --all-files is clean.
• ci(publish): upload-php-pie-release now hard-errors if zero php-package-* artifacts reach the aggregator instead of producing an empty PIE upload. The download step adds if-no-files-found: error, so a future regression that drops all PHP build outputs surfaces immediately instead of silently shipping a release with no PIE assets — the failure mode behind v3.6.11's missing-asset reports (see #333). The matrix-cell tolerance from v3.6.12 (needs.php-extension.result != 'cancelled' && != 'skipped') is unchanged. (.github/workflows/publish.yaml)
• ci(task rust:test): re-include html-to-markdown-rs-dart in the --no-default-features --workspace sweep. The provisional exclusion added earlier in this [Unreleased] cycle is now unnecessary: alef 0.25.33 + the queued [Unreleased] follow-up drop #[cfg(feature = ...)] from every dart-wrapper mirror declaration and the bidirectional From impls, so the wrapper crate compiles cleanly under default, --no-default-features, and --all-features. Verified locally against a fresh task alef:generate. (.task/languages/rust.yml)
• chore(deps): bump alef.toml.alef_version to 0.25.33 and regenerate every binding. Sweeps in the cross-language fixes accumulated through 0.25.30–0.25.33 plus the (still-[Unreleased]) dart cfg follow-up that the regen incorporates locally: pyo3 convert(...) / ConversionOptions(__init__) visitor kwarg widened to HtmlVisitor | object | None (resolves #403); swift options-field factory exported as make{Trait}Handle (matches docs snippets + e2e generator); java record + builder PMD cleanup (per-instance non-final fields, redundant component docs removed); kotlin file-level @file:Suppress extended with ReturnCount + NestedBlockDepth on the shared emitter; codegen Vec<core::T> → Vec<wrapper::T> conversion on non-opaque method returns (pyo3, magnus, extendr); wasm Option<Vec<UnitEnum>> getter/setter emission; php untagged-data-enum delegation via serde_json::from_value; extract honors #[cfg_attr(alef, alef(skip))] on impl blocks (no more duplicate #[no_mangle] symbols on builder + field name collisions); cfg-gated public function re-exports treated as binding surface; extendr extendr_module! registration entries gated on the source FunctionDef cfg; dart mirror enum + struct declarations + bidirectional From impls all unconditional now so frb_generated.rs resolves against the local crate regardless of the dart wrapper's feature set. Pin will advance again to a tagged alef revision once the [Unreleased] dart follow-up + extendr fix ship in 0.25.34.

Fixed

• style(test_apps/go): shfmt-normalize download_ffi.sh so CI Lint's shfmt hook stops rejecting the v3.6.12 baseline. The hand-written cgo library stager shipped with v3.6.12 used inline case-arm bodies; CI's shfmt -i 2 -ci -bn -s profile splits them onto separate lines. CI Lint failed on every v3.6.12 commit until the file was normalized.
• (via alef 0.25.26–0.25.28) Generated bindings pick up: PHP shared lossy and enum-tainted binding-to-core helpers now skip binding_excluded fields and emit ..Default::default() so core types with custom Default impls (e.g. anything that pulls config from the environment) are no longer shadowed by zeroed field defaults across Python/Node/Ruby/WASM/extendr/PHP method bodies and From-impls; FFI same-name function dedup moved out of the shared extractor pass into a backend-local pass (backends::ffi::gen_bindings::functions::cfg_dedup::dedup_same_name_functions) so every other backend and the e2e call-export validator see the original multi-entry surface untouched (v0.25.26 had over-collapsed the shared surface and stripped alef(skip)-tagged siblings from every backend); FRB Dart bridge functions wrapping core functions that return primitives now emit the cross-type cast (e.g. .map(|v| v as i64)) instead of the redundant .map(|v| v) that v0.25.25–0.25.27 emitted; generated Kotlin Android files add ReturnCount to the @file:Suppress list so detekt no longer fails sealed-class deserializers with 3+ variants.
• (via alef 0.25.27) Generated Swift bindings emit the factory function as make{Trait}Handle (matching the documented spec, the docs snippets under docs/snippets/swift/visitor/, and the e2e test generator) instead of make{Trait}{TypeAlias} (which silently doubled the trait stem to makeHtmlVisitorVisitorHandle); generated Swift e2e visitor closures qualify the context type with the host module (HtmlToMarkdown.NodeContext) so the unqualified reference is no longer ambiguous against RustBridge.NodeContext that the test file also imports.
• (via alef 0.25.27) Generated TypeScript WASM e2e configs override SsrfPolicy.denyPrivate = false when the binding exposes the field, since WASM has no std::env::var and SsrfPolicy::from_env() always falls back to deny_private = true, which rejected the localhost mock-server requests every WASM e2e fixture targets.

Changed

• Bump alef pin to 0.25.28 (was 0.25.25), regenerating all binding outputs, e2e codegen, API reference docs, and test_apps scaffolds.

Fixed

• test_apps/go: stage cgo FFI library into the binding's module-cache .lib/<platform>/ so smoke tests link cleanly. The published Go binding declares // #cgo LDFLAGS: -L${SRCDIR}/.lib/<platform>/ -lhtml_to_markdown_ffi, but ${SRCDIR} resolves to the binding's source directory under GOMODCACHE, which is empty after go mod download. The package's own cmd/download_ffi is //go:build ignore-tagged and only invocable via the binding's own go generate, which test_apps doesn't run. Fix: test_apps/go/download_ffi.sh reads MODULE_VERSION from go.mod, downloads the matching html-to-markdown-rs-ffi-v<version>-<rust-triple>.tar.gz artifact from the GitHub release, caches it under ${XDG_CACHE_HOME:-~/.cache}/html-to-markdown-ffi/, makes the binding's module-cache subtree writable, and copies the library into <binding>/.lib/<platform>/. The smoke task invokes the script before go test. Restores Go to the registry-mode smoke matrix.
• ci(publish): replace single-success gate on upload-php-pie-release with cancelled/skipped guards so partial matrix success still publishes the available PIE archives. The job was gated on needs.php-extension.result == 'success', which meant a single transient matrix-cell failure (e.g. the ENOTFOUND artifact-upload flake observed on the v3.6.11 publish run) cascaded into skipping the entire PIE upload step. With the matrix already declared fail-fast: false and the in-job actions/download-artifact@v4 step configured with pattern: php-package-* + merge-multiple: true, the upload now proceeds whenever at least one matrix cell produced an artifact. Transient flakes no longer block the entire release surface.
• (via alef 0.25.20–0.25.25) Generated binding suites pick up: NAPI TypeScript import { A as B } → CJS { A: B } rename translation (so oxfmt no longer aborts on Expected ',' or '}' but found 'as'); Go FFI copyLibraryToBindingPackage no-op when source aliases destination (avoids 0-byte libhtml_to_markdown_ffi.dylib after go generate); Swift Package.swift v__ALEF_SWIFT_VERSION__ placeholder substitution at scaffold-write time so SwiftPM consumers don't 404 against the release asset URL; Homebrew run_tests.sh formula-installed CLI preflight using the parameterized binary name; alef post-generation formatter pipeline aligned with downstream prek hooks (ktfmt for Kotlin format, gofmt+goimports for Go, oxfmt for TS/JSON, shfmt for shell scripts, php-cs-fixer for PHP, cargo sort for emitted Cargo.toml). Resolves CI Lint formatter divergence that had been red on every commit since v3.6.11.
• (via alef 0.25.25) Generated PHP test_apps install.sh emits pie install --version "$VERSION" "<pkg>" instead of the deprecated pie install "<pkg>:$VERSION" form that PIE 1.4.5+ rejects with Unable to find an installable package <pkg> for version <ver>. Restores PHP to the registry-mode smoke matrix.
• (via alef 0.25.25) Generated [crates.dart] excluded_default_features / [crates.swift] excluded_default_features keep optional cargo features out of the wrapper's default = [...] array while still declaring them as opt-in forwarding entries, preventing target-conditional cross-compile activation of features whose system deps aren't cross-compile-ready.
• (via alef 0.25.25) Generated publish/vendor flow retries cargo update + cargo metadata on crates.io registry-index propagation lag (up to 6 attempts × 30 s) so per-language build jobs don't hard-fail in the first few minutes after Publish Rust crates completes.

Changed

• Bump alef pin to 0.25.25 (was 0.25.19), regenerating all binding outputs, e2e codegen, API reference docs, and test_apps scaffolds.

Fixed

• Table layout pre-pass: skip nested-table rendering during column-width measurement (issue #406, residual fix). The MAX_CELL_WIDTH = 200 cap shipped in v3.6.10 (4013a6864) bounded the discarded output but not the measurement CPU. For deeply nested layout HTML (e.g. the reporter's Outlook digest: 393 <table> tags, 851 KB), cell_text_content still recursively dispatched handle_table_with_context on every nested table during the outer measurement pre-pass, triggering its own pre-pass on every descendant cell — combinatorial explosion (cells × nested_cells × ...) unbounded at greater nesting depth. The reproducer still ran for tens of minutes on v3.6.10. The fix threads measure_width_only: bool through the conversion Context; walk_node's "table" arm short-circuits to descendant text content when set, keeping the pre-pass linear in descendant character count. The reproducer now converts in 0.04 s. Regression test nested_layout_tables_convert_within_wall_clock_budget covers a synthetic 4×4 nested-cell fixture with a 10s wall-clock budget. Tier-1 vs Tier-2 separator-row dash counts now diverge on the nested-table fallback (Tier-1 still measures the rendered cell text); existing tier-divergence tests were updated to assert outer-row content equality instead of byte-equality. Resolves the residual #406 report from hobofan on 2026-06-16.

• (via alef 0.25.19) Generated Swift app harness migrates fixtures JSON from triple-quote multi-line string literal to chunked-array [...].joined(), avoiding Swift's multi-line string literal content must begin on a new line error when the Jinja whitespace-trim placed content on the same line as the opening """.

• (via alef 0.25.19) Generated FFI service-API codegen clones borrowed opaque-pointer params at the call site so consuming Rust APIs that take T by value receive an owned value while the C caller retains the original handle for its own _free call.

• (via alef 0.25.19) Generated csharp e2e csproj template branches <RuntimeIdentifier> on OSArchitecture, picking osx-arm64 / linux-arm64 / win-arm64 on arm64 runners instead of hardcoded *-x64.

• (via alef 0.25.19) Generated magnus binding Cargo.toml emits a cfg-feature forwarding [features] block so any #[cfg(feature = "X")] arms in the binding compile under -D warnings.

Added

• (via alef 0.25.19) Generated language doc pages translate Rust type spellings to language-native terminology in prose (Python list[X] / dict, TypeScript X[] / Record, Go []X / map, etc.), applied via map_non_code_lines so code fences stay intact.

Fixed

• Table column-width: cap per-cell measurement at 200 characters (issue #406). Converting Microsoft-style HTML emails with hundreds of nested layout tables produced runaway output (73 MB / 2.2 s for the reporter's 851 KB reproducer) because collect_row_cell_widths used the rendered width of each cell — including any inner table's separator rows — as the outer column width. The outer table's separator was then emitted with that many dashes, which fed back into the grandparent's measurement, doubling at every nesting level. Capping the per-cell measurement at MAX_CELL_WIDTH = 200 bounds total output to O(cells × 200) and keeps both the Tier-1 fast path and the Tier-2 walker numerically consistent. The reproducer now converts in 0.47 s producing 218 KB of markdown. Bisected by the reporter to alef-driven Arc<Mutex<>> visitor migration in 3.4.1 (7f6178f25); the v3.6 series already fixed the visitor-mutex hot loop in 4863d1ab6, but the underlying exponential-width feedback remained. Regression test added: deeply_nested_layout_tables_do_not_produce_runaway_output.

• Bump alef to 0.25.18. Picks up: (a) the e2e visitor codegen fixes for Node and C# — Node tests now pass { visitor: V as any } through options.visitor rather than as a silently-dropped third positional argument, C# tests merge into the existing new ConversionOptions() literal rather than appending a fourth arg, restoring every Custom-substitution visitor test. (b) The Zig e2e build.zig fix dropping the duplicated _run suffix in test-sequencing dependOn calls (conversion_run_run → conversion_run), unblocking Test: Zig. (c) The Swift box-delegate cast fix removing the spurious Int(...) wrap on usize/isize args so the bridge call matches the UInt protocol declaration, unblocking Test: Swift. (d) The Ruby Rakefile modifier-if fix for cross_compile_versions assignment, removing the Style/IfUnlessModifier rubocop offense that broke all 4 Test: Ruby matrix jobs. (e) The PHP PIE URL {OSLower} placeholder fix so pie install xberg-io/html-to-markdown resolves the correct asset name (resolves h2m #333). (f) The binding-crate feature passthrough block emission in FFI/Node/PHP/Wasm Cargo.toml — each binding crate now declares metadata, visitor, inline-images, testkit as passthrough features forwarding to html-to-markdown-rs/X, fixing the unexpected cfg condition value errors under RUSTFLAGS="-D warnings" for code paths gated by core features. (g) The swift-bridge owner-type extern block + cfg-gating fix preventing proc-macro expansion failures on cfg-disabled types. (h) The JNI trait-use emission fix so Tier-B Rust-public trait extension points are reachable from the generated JNI shims.

Fixed

• Bump alef to 0.25.17. Picks up the dart unreachable_patterns allow attribute for the crate-root, which was missing from the dart gen_rust_crate scaffold. v3.6.8's CI Rust failed with unreachable pattern errors at packages/dart/rust/src/lib.rs:1739 and :2102: the dart enum-conversion path emits an _ => unreachable!("cfg-gated variant ... not active in this build") catch-all so the match remains exhaustive when a #[cfg(feature = "X")]-gated variant is compiled out, but the dart binding's [features] table forwards testkit unconditionally, so the cfg-gated arm IS compiled in and the catch-all is unreachable — -D warnings turned the lint into an error. alef 0.25.17 adds unreachable_patterns to the existing #![allow(unused_variables, unreachable_code)] crate-root attribute, matching the swift backend's already-correct allow list.

Fixed

• Bump alef to 0.25.16. Picks up the vendor manifest_abs canonicalize fix (resolves Elixir NIF / PHP extension / Ruby gem / Python sdist alef publish prepare failures from the v3.6.7 publish run), the Dart cfg(testkit) whitespace fix (unblocks Validate: Rust and Test: Dart on main), the rustler .clone() skip for reference parameters, the JNI workspace-target host fix, the extendr enum type-path resolver, the swift From<core> cfg-gating for variant arms, the FFI visitor enum-context i32 emission, the visitor_result bare-string Custom routing, the e2e csharp SDK-AssemblyInfo suppression, prerelease set-version support (0.25.10–11); the swift cfg-union postprocessing fixes for default-build wrapper-type emission and the default = [<features>] Cargo.toml emission (0.25.12–15); and the drop of cfg propagation on enum From-impl match arms — binding crates do not declare gated features themselves but pull the core dependency with them enabled, so propagating #[cfg(feature = "testkit")] to binding-side arms produced unexpected cfg condition value: testkit errors under -D warnings on py/node bindings (0.25.16).
• C# assembly identity now tracks <Version>. Deleted the hand-committed packages/csharp/HtmlToMarkdown/Properties/AssemblyInfo.cs (carrying a stale AssemblyVersion("3.4.0")) and switched the scaffold to let the .NET SDK derive AssemblyVersion, AssemblyFileVersion, and AssemblyInformationalVersion from <Version> plus the new <Company> / <Product> MSBuild properties. The published 3.4.0 assembly identity was breaking task test-apps:smoke:csharp against every NuGet package since the original ship.

Changed

• CI E2E PHP/Ruby builds: re-enable rewrite-native-deps. The workaround in 3.6.7 (a8c7fe40c) disabled rewrite-native-deps on PHP and Ruby build-* actions to dodge the alef 0.25.9 canonicalize bug. With 0.25.11's fix the action works correctly again, so the four rewrite-native-deps: "false" overrides are removed.

Fixed

• Bump alef to 0.25.7 — fixes alef publish prepare for non-workspace-member NIF crates (Ruby gem, Elixir NIF). alef 0.25.4–0.25.6 had a bug where cargo update --locked and cargo metadata --locked would fail for binding crates that are not workspace members (like the Rustler NIF and Magnus gem). The seed lockfile lacked a [[package]] entry for the binding crate, causing cargo to reject it. alef 0.25.7 dropped --locked from the metadata validation step and set .env_remove("CARGO_BUILD_LOCKED") to allow cargo to resolve these crates from the registry. This fix restores Ruby (all platforms) and Elixir NIF (all platforms + Hex package) support.

Fixed

• Elixir Hex/NIF + Ruby gem publish: bump alef pin to 0.25.4 so alef publish prepare produces a valid binding lockfile. alef 0.25.1's vendor::scrub_or_regenerate_lock strict-mode path failed on every v3.6.4 Elixir NIF and macOS/Linux Ruby gem build with cargo update -p <lockfile> (or final cargo metadata validation) failed (exit code 101) ... cannot update the lock file ... because --locked was passed — the seed lockfile's workspace-member path entries collided with the registry-source entries the rewrite added, and the final cargo metadata --locked validation could not reconcile them. alef 0.25.3 added strip_workspace_member_entries to drop the path-source entries from the seed before per-member cargo update -p runs, plus a full registry-URL package-id spec (registry+https://github.com/rust-lang/crates.io-index#NAME@VERSION) to disambiguate the per-member update. 0.25.4 also escapes Rust reserved keywords in extendr struct fields (relevant to R bindings consuming flat data enums with serde(tag = "type")).

• Python sdist on Alpine/musl: actions/rewrite-native-deps v1.8.69 now strips path = "..." from [workspace.dependencies] entries. The 3.6.4 sdist's root Cargo.toml shipped with [workspace.dependencies] html-to-markdown-rs = { version = "3.6.4", path = "crates/html-to-markdown" }, and cargo eagerly validates every workspace-dep entry on pip install — bailing with failed to read .../crates/html-to-markdown/Cargo.toml because the workspace crate is not bundled in the sdist. v1.8.66 added [patch.*] stripping for sdist consumers (resolved #390) but missed [workspace.dependencies]. The new step drops path from every workspace-dependency entry, leaving the version so the dep resolves from crates.io on consumer install. Resolves #402.

Fixed

• CLI: drop reqwest brotli feature to keep alloc-no-stdlib on 2.x. The transitive brotli crate (pulled in via async-compression) jumped to 8.x which expects alloc-no-stdlib 3.x, but the workspace resolves the sibling at 2.x. The resulting trait drift broke cargo build on stable rustc with the trait bound 'StandardAlloc: alloc::Allocator<...>' is not satisfied, blocking the ubuntu-latest Python wheel build during the v3.6.3 publish run. The CLI's HTTP client now uses gzip+deflate only.

• Publish workflow: dispatch publish-pubdev with the release tag, not the branch ref. When publish.yaml was triggered by release: published, github.ref_name resolved to the branch where the release was authored (e.g. main). The child workflow's OIDC token then carried refType=branch, which pub.dev rejects with publishing is only allowed from 'tag' refType. Dispatch now uses needs.prepare.outputs.tag so the child runs against the tag and the OIDC token is accepted.

• Taskfile: test-apps:test:zig now grep'd the root Cargo.toml for the workspace version. The previous grep targeted crates/html-to-markdown/Cargo.toml, which uses version.workspace = true and has no literal version line — H2M_VERSION resolved to empty and the zig-fetch URL collapsed to …/download/v/html-to-markdown-rs-zig-v.tar.gz (404).

Changed

• Track Cargo.lock for reproducible builds. Cargo.lock was previously gitignored, defeating cargo build --locked everywhere it was used. Every CI runner resolved deps fresh, allowing semver-compatible drift to silently introduce broken transitives (the brotli/alloc-no-stdlib mismatch above). The root workspace lockfile plus the per-package nested lockfiles (R, Ruby, Elixir NIF, e2e/rust, test_apps/rust) are now tracked.

• Pass --locked to cargo build in CI, publish, scripts, and alef.toml hooks. Now that the lockfile is tracked, every CI/publish cargo build runs with --locked so a dirty index can't silently substitute newer transitive deps. Local-dev tasks (.task/languages/rust.yml) intentionally remain without --locked so contributors can pick up dep updates.

• Regenerated cross-language bindings with alef 0.25.1. Pulls in: csharp e2e codegen using KreuzbergConverter facade; swift e2e codegen no longer emits ? chains on non-Optional RustString returns; C e2e codegen panics on missing fields_c_types keys instead of silently miscompiling; FFI/NAPI/PyO3/Magnus/Rustler test surface cleanup; vendor::scrub_or_regenerate_lock preserves workspace lockfile pins via per-member cargo update + cargo metadata --locked validation; NAPI strips the readonly keyword from emitted service.cjs.

Fixed

• Ruby gem: Rakefile reverted to v3.5.5 working pattern. v3.6.0's alef 0.21.0 regen introduced RbSys::ExtensionTask with manual Dir.chdir nesting that broke nested file "Cargo.lock" task declarations. Reverts to the v3.5.5 Rake::ExtensionTask pattern for all 5 platforms (macOS arm64/x86_64, Linux x86_64/aarch64, Windows x64). Resolves bundle exec compilation failures.

• Zig: curl HTTP/2 support. Zig's vendored curl bindings required +h2 feature flag for HTTPS URL fetch operations. Updated packages/zig/build.zig.zon to enable the feature, restoring GitHub-release downloads on Zig consumers.

• Homebrew bottle ordering stabilized. alef v0.20.5 sort order for bottle entries now matches brew audit expectations; formulae no longer fail the Homebrew official-tap checklist.

Added

• Tiered HTML-to-Markdown conversion architecture. Clean HTML inputs now have an opt-in fast path through a Tier-1 single-pass byte scanner (converter/tier1/); on anything the scanner cannot prove byte-equivalent to the existing Tier-2 DOM walker, it returns a structured bail and the dispatcher falls back to Tier-2 (tl::parse + walk_node) transparently. Output is always byte-equal to what Tier-2 would have produced for the same input — verified by 116 oracle snapshots and a per-fixture byte-equality integration test (tests/tier1_byte_equality_test.rs). Tier-3 (html5ever repair) remains the fallback for truly malformed HTML.

• ConversionOptions::tier_strategy (TierStrategy::Auto | Tier2 | Tier1) for runtime tier selection. Auto (default) lets the classifier decide based on the prescan signals and options shape; Tier2 forces the existing DOM-walk path; Tier1 is testkit-only (#[cfg(any(test, feature = "testkit"))]) for debugging and benchmarking. Exposed to Node (tierStrategy: "auto" | "tier2") and Wasm (WasmTierStrategy enum). CLI and Python pick up the field via the standard options-mapping flow.

• Tier-1 router style-option gate. The classifier forces Tier-2 when any of these deviate from Tier-1's hardcoded value: heading_style, code_block_style, strong_em_symbol, bullets, list_indent_*, whitespace_mode, newline_style, escape_* flags, output_format, link_style, url_escape_style, compact_tables, default_title, sub_symbol, sup_symbol, highlight_style. 47 integration tests enforce the gate.

• Tier-1 conservative bail set. Tier-1 returns Err(BailReason::*) rather than emit potentially-wrong output on: custom elements, CDATA, unescaped <, inline SVG, HTML 5 optional-close edge cases, <table> with rowspan/colspan/block-children-in-cells/ caption/mixed-section-order, nested lists (Tier-2 cycles bullets by depth), <pre> with non-Indented code_block_style, named HTML entities outside the 45-entry zero-alloc table, table cells containing |, and <br> inside table cells. Tests cover every variant.

• Benchmark harness (tools/benchmark-harness/, binary htmbench) with run / compare / oracle / oracle:bless / survey / mdream subcommands. Per-group regression guardrails (baselines/baseline.json, guardrails.json). Wired under task bench:* namespace.

• Bench regression gate in CI — every PR that touches the Rust core or bench harness now runs task bench:oracle && task bench:run && task bench:compare on ubuntu-24.04-arm, failing on any fixture that exceeds its per-group threshold in tools/benchmark-harness/guardrails.json (5% clean_large, 8% clean_medium, 10% other groups, 30% adversarial). Baselines are blessed deliberately by humans, not automatically by CI.

Changed

• Publish workflow now authenticates via the kreuzberg-dev-publisher GitHub App (org-level BOT_APP_ID / BOT_APP_PRIVATE_KEY) for all writes (own-repo pushes, tag updates, release-asset uploads, homebrew-tap commits, Discord dedup marker). OIDC publisher jobs (PyPI/npm/hex/Maven/NuGet/crates) are unaffected. HOMEBREW_TOKEN is no longer used.

• BREAKING: NodeContext::attributes is no longer a public field. Access attributes via the new attributes() method (fn attributes(&self) -> &BTreeMap<String, String>). Struct-literal construction of NodeContext is no longer possible; use the provided constructors: with_borrowed_attributes, with_owned_attributes (public), or with_lazy_attributes (pub(crate), for internal use only). Attributes are now lazily materialized from the DOM on first access when constructed via the internal path, eliminating the per-element BTreeMap allocation on the visitor hot path. Measured throughput improvement with visitor enabled (100-iteration harness, Apple Silicon): small_html −29%, medium_python −10%, large_rust −24%, tables_countries −24%.

• DomContext::parent_tag_name now returns Option<&str> instead of Option<String>. This is an internal API (pub(crate)); external consumers are unaffected.

Performance

• Tier-1 byte scanner activated in production (tier_strategy = Auto). The classifier decides per-input whether Tier-1's single-pass byte scanner runs; on bail, the dispatcher falls back to Tier-2 transparently. Measured throughput on the harness corpus (29 fixtures, 6.4 MB total; Apple Silicon, cargo build --release):

  Fixture	Size	ms (best)	Throughput
  real-world/wikipedia/medium_python.html	1.24 MB	62.58 ms	19.0 MB/s
  real-world/wikipedia/large_rust.html	1.07 MB	37.17 ms	27.3 MB/s
  mdream/github-markdown-complete.html	430 KB	10.57 ms	38.7 MB/s
  mdream/react-learn.html	265 KB	12.11 ms	20.9 MB/s
  mdream/wikipedia-small.html	166 KB	5.63 ms	28.1 MB/s
  real-world/issues/gh-121-hacker-news.html	57 KB	1.08 ms	50.3 MB/s
  mdream/nuxt-example.html	3.6 KB	0.029 ms	116.1 MB/s

  Per-group regression thresholds (5–30%) are enforced on every PR via task bench:compare (see Added section).

• memchr-driven text scan: decode_and_collapse_into and decode_entities_into use memchr::memchr3 / memchr::memchr to skip ahead to the next special byte (<, &, whitespace boundary) and bulk-copy plain text runs in a single push_str. Replaces a byte-by-byte conditional inner loop and closes a substantial portion of the gap to main's heavily-optimized Tier-2 path on Wikipedia-scale documents (e.g., +32% on wikipedia-small).

• Tier-1 dispatcher reuses normalized input on Tier-2 fallback. When the Tier-1 scanner bails or the classifier routes to Tier-2, the dispatcher threads the already-computed normalize_input Cow<str> through to the Tier-2 path instead of recomputing it. Eliminates one full-input pass on every bail-fallback or Tier-2-routed call.

• collapse_excess_blank_lines in-place. Replaced the fresh-String rewrite with String::retain, eliminating an output-sized allocation on every Tier-1 success whose output contains \n\n\n. Measured wins (best-of-3, --force-tier1, vs prior commit): wikipedia/lists_timeline -3.81%, gh-121-hacker-news -4.23%, github-markdown-complete -2.99%, wikipedia/medium_python -2.94%, mdream/wikipedia-small -2.68%, mdn-array -2.12%, gh-190/firsteigen -2.55%. No fixture regressed.

• htmbench --force-tier2 flag mirroring --force-tier1, for clean head-to-head benchmarks now that the Auto router activates Tier-1 on most fixtures and so cannot be used as a Tier-2 control.

• convert() accepts options as a bare ConversionOptions in addition to Option<ConversionOptions> (resolves #398). The second parameter now bounds impl Into<Option<ConversionOptions>>, so convert(html, opts), convert(html, Some(opts)), convert(html, None), and convert(html, ConversionOptions::default()) are all valid Rust call shapes. Existing callers continue to compile unchanged — this is purely additive flexibility, not a breaking change. The ~250-line conversion body is held in a private non-generic convert_inner so the generic wrapper monomorphises exactly once per call site rather than per Into impl chosen.

• url_escape_style option (UrlEscapeStyle::Angle | UrlEscapeStyle::Percent). When set to Percent, link and image destinations are percent-encoded instead of wrapped in angle brackets, producing output that all Markdown parsers handle correctly even when the URL contains <, >, spaces, or parentheses (resolves #392).

Fixed

• Non-deterministic SVG attribute serialization in converter/media/svg.rs: serialize_element iterated tag.attributes() over astral-tl's internal HashMap, which has non-deterministic iteration order. SVG data: URIs therefore differed across runs. Fixed by sorting attributes by name before emission, restoring determinism.

• spurious blank lines after frontmatter and lists (MD012) (resolves #399). Block-level emission now collapses runs of three or more consecutive newlines into exactly two, so the frontmatter→body and list→next-block transitions no longer produce extra blank lines that violate markdownlint MD012.

• autolinks: bare paths and filenames are no longer wrapped as autolinks (resolves #397). Per GFM §6.5, autolinks require an absolute URI with a scheme — but the previous check only compared the link text to the href, so <a href="foobar.png">foobar.png</a> became the invalid <foobar.png> (which parsers read as a literal HTML tag). Added has_uri_scheme helper that validates the RFC 3986 scheme grammar (ALPHA *( ALPHA / DIGIT / "+" / "-" / "." ) followed by :). Bare paths, fragments, and filenames now render as [text](href). https://, mailto:, ftp://, data:, and other schemed URLs continue to autolink as before.

• node binding: visitor callbacks (visitText, visitLink, visitHeading, …) now fire (resolves #395). JsHtmlVisitorBridge now stores a persistent napi::bindgen_prelude::ObjectRef<false> obtained via Object::create_ref() and materializes a fresh local Object handle per callback through obj_ref.get_value(&env). The previous bridge stored raw napi_value pointers extracted via transmute_copy and reconstructed via Object::from_raw — but a napi_value is a local handle tied to the HandleScope active at construction time, and by the time visitor methods fired deep inside convert() the scope was no longer active, so get_named_property("visitText") silently returned Err and the bridge fell through to VisitResult::Continue without dispatching. A Drop impl on the bridge calls obj_ref.unref(&env) so the JS object can be GC'd after conversion. Verified against the issue repro: visitText/visitLink/visitHeading all fire. (alef commit 1ffdaafe4)

• code block: CodeBlockStyle::Backticks and Tildes no longer emit a trailing blank line inside the fence and now insert a blank line after the closing fence (resolves #396). The fenced emitter pushed content verbatim (which already ends in \n for any trailing-newline source) plus an extra \n before the closing fence, producing …\n\n```\n. It also closed with a single \n, so following block content butted up against the closing fence with no blank line separator — Indented style was unaffected because its content path strips trailing newlines via .lines().join("\n") and already emits \n\n after. The Backticks/Tildes path now trims trailing newlines from inner content (content.trim_end_matches('\n')) before re-emitting a single \n, and pushes \n\n after the closing fence to match Indented.

• php test_app: PIE install.sh now installs xberg-io/html-to-markdown instead of the non-existent xberg-io/html-to-markdown-rs (resolves #98 / smoke regression). The Packagist project only publishes the un-suffixed name; alef.toml was renamed and the regen picks it up in both install.sh and the inline comment.

• r binding: conversion_options() helper exported in NAMESPACE. alef's R emitter generated the R/options.R helper for ergonomic ConversionOptions construction but never exported it, so htmltomarkdown::conversion_options(...) raised could not find function at runtime — which downstream convert(..., options=) callers then surfaced as the extendr-api 0.9.0 options must be a named list validation error. Resolves #99 / smoke regression. (alef commit 160d504f3)

• java binding: NativeLib.<clinit> no longer throws NoSuchElementException when an optional FFI symbol is missing. The error-context handle lookups (LAST_ERROR_CODE, LAST_ERROR_CONTEXT) used Optional.orElseThrow() mid-static-init, escalating any partial symbol set into a hard NoClassDefFoundError; they now fall back to null and the rest of the loader's null-checks handle the absence gracefully. Resolves #100 / smoke regression. (alef commit d296bfdeb)

• c FFI test_app Makefile now embeds an LC_RPATH so the smoke binary can find the dylib at runtime on macOS without DYLD_LIBRARY_PATH. Adds -Wl,-rpath,$(FFI_LIB_DIR) to the LDFLAGS path. Resolves #101 / smoke regression.

• csharp binding: trait-bridge catch blocks no longer emit unused Exception ex variables. The generated TraitBridges.cs had 25+ catch (Exception ex) blocks where ex was never referenced; with <TreatWarningsAsErrors>true</TreatWarningsAsErrors> the build failed with CS0168, which in turn blocked NuGet publish for 3 releases (root cause of #104). alef now emits bare catch (Exception) when the exception variable isn't actually used. (alef commit 16e81b20d)

CI/Publish

• .npmrc at workspace root: minimum-release-age=0 so the npm Build Node bindings and Build WASM package jobs stop failing at pnpm install time with ERR_PNPM_MINIMUM_RELEASE_AGE_VIOLATION for transitively-recent dep pins. The v3.5.5 fix only patched the test command; this covers every pnpm install call repo-wide. Resolves #96.

• Go subtag publish (packages/go/v3.5.x) is already wired through the xberg-io/actions finalize-release job (publish.yaml:2418 passes go-module-path: packages/go/v3); no action needed here. The reason v3.5.2–v3.5.7 didn't push subtags is upstream main-release-job failures cascading. Resolves #97.

Chore

• alef pin: 0.20.12 → 0.21.0 (local unreleased head; no alef tag). Bindings + e2e suites regenerated against the freshly-rebuilt local alef binary, picking up the cohort fixes above in a single regen.

Fixed

• release: sync workspace Cargo.toml version. v3.5.6's release commit (2c37942f8) claimed to bump the workspace version 3.5.5 → 3.5.6 but the change never actually landed in the commit. Every binding manifest (Cargo.toml, pyproject.toml, gemspec, mix.exs, pom.xml, .csproj, package.json, …) stayed pinned at 3.5.5, so the v3.5.6 publish workflow built v3.5.5 binaries against the v3.5.6 tag and uploaded them as *-v3.5.5-*.tar.gz assets to the v3.5.6 GitHub Release. crates.io / PyPI / Hex / RubyGems / Maven publishes were either no-ops (3.5.5 already exists) or rejected; npm + WASM + NuGet + Homebrew steps also failed. v3.5.6 is skipped; v3.5.7 is the corrected ship of every fix originally rolled into v3.5.6.
• alef pin: 0.20.11 → 0.20.12 (auto-synced by alef sync-versions).

Chore

• bindings: regenerated against alef v0.20.12 with workspace version correctly bumped to 3.5.7 first, so every manifest now matches the release tag.

Fixed

• ci(ruby): cross-compile windows-x64 gem via bundle install inside the rb-sys-dock container. The previous matrix entry ran rb-sys-dock --platform ... -- bundle exec rake "native[$target]" gem, which invoked bundle exec inside the container without first materialising the lockfile against the container's Ruby version. The rb-sys-dock container ships its own Ruby toolchain (4.0.2 preview) while the host Gemfile.lock pins 3.3.11, so bundler failed with "Could not find …" and hung for 47 minutes. The command now wraps the container invocation in bash -c "bundle install --jobs=4 --retry=3 && bundle exec rake …" so the lockfile materialises against the container's Ruby before rake runs. (.github/workflows/publish.yaml)
• ci(elixir): Hex publish no longer 404s on darwin tarball downloads. alef v0.20.2 changed darwin NIF tarballs to .dylib.tar.gz to "match the platform-native extension," but rustler_precompiled 0.9.0 (the latest version on Hex; no .dylib-aware version exists) hardcodes .so for every non-Windows consumer download URL in lib_name_with_ext/2 and ignores all caller overrides. h2m's hand-maintained publish.yaml had already normalised darwin uploads to .so, so h2m's own Hex publish kept working; the bug only surfaced in sibling polyglot repos. The alef v0.20.5 revert (.dylib → .so) restores polyrepo alignment and is picked up by this regen. (alef.toml pin → v0.20.5, xberg-io/actions/generate-elixir-checksums@v1)
• bindings(c): registry test_app download_ffi.sh now hits the correct release asset prefix. The [crates.e2e.registry.packages.c] name was html-to-markdown-ffi, but publish.yaml uploads C FFI tarballs with asset-prefix: html-to-markdown-rs-ffi-. Drift caused task test-apps:smoke:c to 404 on the GH release tarball. (alef.toml)
• bindings(java): registry test_app now ships the Maven wrapper (mvnw, mvnw.cmd, .mvn/wrapper/maven-wrapper.properties). Previously missing because mvnw emission landed in alef v0.20.2 and h2m was pinned at v0.20.1. (alef.toml pin → v0.20.5)
• bindings(homebrew, c, …): every alef-emitted *.sh (e.g. run_tests.sh, download_ffi.sh) is now created with the +x bit set. alef's write_scaffold_files_with_overwrite() skipped the shebang-chmod helper that write_files() applied, so every alef-generated shell script in e2e/ and test_apps/ landed as -rw-r--r--, breaking task test-apps:smoke:homebrew with "permission denied" on ./run_tests.sh. Fixed by alef v0.20.3's shared apply_shebang_chmod() helper called from both writers. (alef.toml pin → v0.20.5)
• bindings(go, php, swift, csharp, dart, kotlin_android, zig, …): trait-bridge codegen cohort fixes. PHP refcount safety (inc_count/dec_count via PhpRc), Go duplicate //export removal + cgo.Handle.Delete defer/recover, Swift async/throws + try await order + JSON-encode conditionally, C# callback method naming + bool→int + IntPtr userData + usize/isize mapping, Dart trait-import + factory wrapper required-only methods + RID-aware published-loader, Kotlin Android useJUnitPlatform() in registry mode, Zig error-union removal from test-backend stubs, Java trait-method emission incl. default-impl methods + ffi_skip_methods honouring in I{Trait} interface emission. (alef.toml pin → v0.20.5)
• bindings(elixir): rustler upgraded 0.37 → 0.38. (packages/elixir/native/html_to_markdown_nif/Cargo.toml)
• bindings(php): PHP trait-bridge async no longer panics on "Cannot start a runtime from within a runtime." Generated async method bodies now prefer Handle::try_current() before WORKER_RUNTIME.block_on(...) so the bridge is safe to call from within an outer tokio runtime. (alef.toml pin → v0.20.5)
• bindings(wasm, node): test_apps pass --config.minimumReleaseAge=0 to pnpm test so freshly-published RC packages clear pnpm's supply-chain policy check. (alef.toml pin → v0.20.5)

Chore

• bindings: regenerated against alef v0.20.5. Folds in every fix from v0.20.2 through v0.20.5 — see alef CHANGELOG for the full backend cohort.
• deps(java): jackson-databind + jackson-datatype-jdk8 2.21.2 → 2.21.3. (packages/java/pom.xml)
• deps(rust): reqwest 0.13.3 → 0.13.4 in CLI binary. (crates/html-to-markdown-cli/Cargo.toml)
• deps(js): pnpm packageManager 11.3.0 → 11.4.0. (package.json)
• taskfile(elixir): tolerate mix hex.outdated non-zero exits before mix deps.update --all. (.task/languages/elixir.yml)

Fixed

• ci(node): restore alef-generated index.d.ts after napi build in the node-typescript-defs publish job. The napi-rs macros deliberately filter out the *Update DTO types (ConversionOptionsUpdate, PreprocessingOptionsUpdate), so the d.ts regenerated by napi build lacks them; the wrapper at packages/typescript/src/index.ts re-exports those names and tsc fails with TS2724 on every publish. The publish job now git checkout HEAD -- crates/html-to-markdown-node/index.d.ts between napi build and the artifact copy, preserving alef's augmented d.ts.
• ci(ruby): cross-compile windows-x64 gem via rake-compiler-dock from the Linux runner. The previous matrix entry's cargo build --target x86_64-pc-windows-gnu against the ucrt64 MSYS2 toolchain corrupted a linker argument and failed every release with cannot find -l■. Linux-host docker-based rake-compiler-dock is rb-sys's recommended cross-build path and matches what every other rb-sys gem uses for Windows.
• bindings(elixir): RustlerPrecompiled now resolves the correct platform extension on macOS. v0.20.0's rustler emit lets RustlerPrecompiled's built-in mapping pick .dylib for *-apple-darwin targets and .so for *-linux-*, so mix deps.get no longer 404s against *.so.tar.gz on darwin consumers.
• alef hash: per-file alef:hash: now computed over generation inputs, not emitted content. Post-format whitespace drift no longer invalidates alef verify, so CI Lint stops reporting bindings as stale after every prek --all-files cycle.
• bindings(java): test_app pom.xml drops -Djava.library.path=.../target/release in registry dep_mode. The Maven-Central JAR bundles natives under /natives/{rid}/ and alef's loader extracts them at startup; overriding the library path to a non-existent local directory broke UnsatisfiedLinkError on smoke runs. Override is now emitted only in local dep_mode.
• bindings(c): test_app Makefile no longer requires a local target/release/ build to resolve the FFI. download_ffi.sh is skipped only when both the FFI header and shared library are present locally; otherwise the published tarball is fetched. Smoke runs from a clean checkout work without a prior cargo build.
• bindings(php): registry test_app installs the PIE-distributed extension via install.sh before composer install. Removes the implicit "ext-html_to_markdown must be pre-installed" requirement.

Chore

• bindings: regenerated against alef v0.20.1. Folds in B6 hash semantics, java/c e2e build-path fixes, php install.sh, vendored Cargo workspace marker, scaffold persistence (rustc job cap + Node memory cap), wasm e2e import dedupe, service_api emitter family for csharp/dart/go/swift/zig/jni/ffi/extendr/napi/magnus/php/rustler/pyo3 with real dispatch (not yet wired in h2m but available for downstream features), zig platform-suffixed URLs in build.zig.zon, kotlin nullable bare result assertions, and php anonymous-class super_trait name() dedup.

Fixed

• core: prevent silent truncation on XHTML-style self-closing tags (<td/>, <br/>, etc.) embedded in EPUB-derived HTML. The bundled astral-tl parser treats / as an identifier character, so <td/> was parsed as a tag literally named "td/" and subsequent siblings nested under it — table rows collapsed into a single cell and any content after the broken table was dropped. convert_api::normalize_input now preprocesses <tag/> → <tag /> before tokenization so the trailing slash is read as a self-closing marker. Regression covered by tests/issue_391_xhtml_self_closing.rs. Closes #391.
• docs(python): visitor API reference rewritten to match the actual duck-typed binding. The generated docs/reference/api-python.md documented a class MyVisitor(VisitorHandle): subclass pattern with VisitResult.Continue enum returns, but VisitorHandle is #[pyclass(unsendable, from_py_object)] (sealed; cannot be subclassed) and VisitResult exposes only property getters (VisitResult.Continue raises AttributeError). The trait rustdoc on HtmlVisitor now leads with the plain-class + string/dict return idiom that the magnus-style bridge actually accepts. Closes #389.
• packaging(python): unblock PyPI sdist build from Alpine/musl and other no-precompiled-wheel platforms. PyPI 3.5.1's sdist was missing the core crates/html-to-markdown/ directory because a stale .gitmodules entry pointing at a deleted homebrew-tap submodule caused cargo package --list to fail silently during the CI maturin run, so maturin only bundled the PyO3 crate and shipped a sdist that could not build. Removed the stale .gitmodules; maturin's path-dependency auto-bundling now works again and the resulting sdist contains all 177 core-crate files. Closes #390.
• ci(swift): Swift Artifact Bundle publish job uses the renamed crate html-to-markdown-rs-swift. Stale html-to-markdown-swift reference broke the Swift bundle step on every release since v3.5.0.

Chore

• bindings: regenerated against alef v0.19.22. Pulls in the e2e green-up cohort (csharp/php/extendr/rustler/swift/zig/dart/go/java/ruby/elixir trait-bridge emitter fixes) and drops alef's broken [tool.maturin] include directive (maturin rejects archive paths with ..).