Skip to content

Releases

v4.2.0 — the compact duck_blocks line format; dense element_order from duck_blocks_normalize

Choose a tag to compare

@teaguesterling teaguesterling released this 20 Nov 20:36
c978e07

MINOR. The release adds a compact line format for duck_blocks, as three SQL macros and a vendorable C++ header, and it fixes two producer defects. The spec stays at 1.4.

Added

  • The compact line format (#86, #90, #91, #93, #94). It writes one JSON object per line, one line per element. The fields are one letter (t c l e a m), the types and attribute keys are short codes, and NULL and default fields are left out. The line number is the element_order. Measured on 16 duckdb_panduck fixtures, it is 0.53 of pandoc JSON raw and 0.92 with zstd, against 1.68 and 1.37 for COPY ... (FORMAT json) of the same rows.
    • duck_blocks_to_compact(blocks) and duck_blocks_from_compact(text) convert to and from a duck_block list. read_compact_blocks(path) reads one or more files as rows, and a glob works.
    • Type codes: a block is UPPERCASE, an inline is lowercase and a value is a symbol. All 50 types in the spec 1.4 vocabulary have a code. Any other type is written as kind:element_type.
    • The header line is {"@":"4.2.0"}, the version of the code tables, a constant. Codes are only ever added. A reader refuses a type code or an attribute code it does not know, so a file from a newer table fails loudly instead of losing a field.
    • The writer refuses a NULL level, encoding, attributes map or attribute value, rather than writing a default.
    • The readers stream. No macro has a subquery body, so the cost grows with the file (measured: 486,000 lines in 4 files read in 1.4 s). read_compact_blocks numbers lines in scan order, so it refuses to run with preserve_insertion_order off.
    • vendor/duck_block_compact.hpp holds the code tables, TABLE_VERSION and a C++ codec on DuckDB's bundled yyjson. The SQL macros are built from its tables at load. duckdb_panduck vendors it for its native .dblocks reader and writer. test/fixtures/compact/golden is the corpus both implementations are held to.

Fixed

  • duck_blocks_normalize keeps element_order dense (#89, duckdb_panduck#206). Folding a lone plain into its parent left a gap: a two-item tight list came back as 0, 1, 3, 5.
  • The legacy duck_block_heading(content, level) carries level 1 (#87, #88). It returned a NULL level, so its block failed duck_blocks_validate. It was the only one of 116 builder overloads that did.
  • test/check_vendorable.py compiles as C++17 (#92). DuckDB v2.0's own headers do not compile as C++11, so the check failed on every tree.

Measured

CI run 44802413402 on the merge commit c978e07, after a re-run of the canary jobs. In the first attempt, canary linux_arm64 failed to download a Yum repository's metadata while building its Docker image, and canary linux_amd64 was cancelled.

Build Tests
v2.0.0 pin: linux_amd64, windows_amd64 18 passed, 0 skipped
v2.0 next: linux_amd64, windows_amd64 18 passed, 0 skipped
v2.0.0 pin and v2.0 next: osx_arm64 16 passed, 2 skipped
DuckDB main canary: linux_amd64 18 passed, 0 skipped. This is the leg #94 was fixed for: before it, compact.test failed here
DuckDB main canary: osx_arm64 16 passed, 2 skipped
DuckDB main canary: windows_amd64 fails, in DuckDB. MSVC stops in DuckDB's own duckdb/storage/arena_allocator.hpp(160): error C2665 while compiling DuckDB main. Canary windows_amd64_mingw was cancelled
wasm_mvp, wasm_eh, wasm_threads, linux_arm64 build passes. I read the test line only for the rows above.

The build inputs (vcpkg.json, extension_config.cmake, CMakeLists.txt) are unchanged since v4.1.0.

v4.1.0 — sections for any reader; block JSON through DuckDB's yyjson

Choose a tag to compare

@teaguesterling teaguesterling released this 17 Nov 19:52
d4d45cd

MINOR. One new table macro, duck_blocks_sections. Block JSON is now read only with the yyjson that DuckDB vendors. duck_block_utils has no JSON parser of its own.

Added

  • duck_blocks_sections(blocks) returns the columns of read_markdown_sections for the blocks of any reader: one row per heading, with section_id, section_path, level, title, content, parent_id, start_order, end_order and blocks. duck_blocks_sections_structs(blocks) is the scalar behind it. (#82, #83)
    • A section ends before the next heading of any level. This is the default of read_markdown_sections.
    • Text before the first heading is not a section.
    • section_id is always the slug of the title, with the same duplicate rule as duckdb_markdown (a, a-1, a-1-1).
    • On this repo's README and docs/*.md, 589 sections agree with read_markdown_sections on id, path, level, title and parent.

Changed

  • Table and list content is parsed with DuckDB's yyjson (duckdb/third_party/yyjson), not a hand-written parser. (#85)
  • yyjson is strict, so content that is not valid JSON no longer parses partly.
    • duck_blocks_to_text returns that content as written, so a text search still finds its words.
    • duck_blocks_render_ansi renders a table with such content as a paragraph. A list already did this.

Fixed

  • The build against DuckDB main compiles again. DuckDB main commit 7cda1961d02 changed ExpressionState::GetContext(). The new CompatClientContext gets the ClientContext on both versions. v2.0.0 builds do not change. (#77)

Not in this release

duck_block_table_read was on main from #80 to #85. No release contained it. It is now panduck_table_read in panduck v0.11.0. A consumer that pins a main commit from that range must change to panduck's function.

Measured

CI run 43928562371 on the merge commit d4d45cd:

Build Tests
v2.0.0 pin: linux_amd64, windows_amd64 17 passed, 0 skipped
v2.0 next: linux_amd64, windows_amd64 17 passed, 0 skipped
DuckDB main canary: linux_amd64, windows_amd64 17 passed, 0 skipped
wasm_mvp, wasm_eh, wasm_threads, linux_arm64, osx_arm64, windows_amd64_mingw build passes. I read the test line only for the rows above.

v4.0.1 — table cells decode JSON escapes

Choose a tag to compare

@teaguesterling teaguesterling released this 11 Nov 23:02
a13179e

PATCH. No API change. duck_blocks_to_text output changes for table cells that hold an escape.

Fixed

  • A newline in a table cell printed as n. TableJsonToText dropped the backslash of every JSON escape and kept the letter. webbed emits a <td> that holds a <ul> as "\n\nx\ny\n\n", which came back as nnxnynn. A tab printed as t, and a u-escape such as 00e9 printed as its hex digits. (#75)
  • A newline in a cell is now a newline in text output, not a space, which matches paragraphs and code blocks. Cell text is not trimmed.
  • Deeply nested table JSON crashed the process. 200000 nested brackets segfaulted both duck_blocks_to_text and duck_blocks_render_ansi. The parser now stops at depth 256 and drops the rest.
  • A u-escape with fewer than four hex digits ate the closing quote, and the next cell disappeared. Exactly four hex digits are now required. Anything else decodes like an unknown escape.

Measured

CI on the merged head: linux_amd64 and windows_amd64, for both the v2.0.0 pin and v2.0 next, ran 15 passed, 0 skipped.

v4.0.0 — the Pandoc converter moves to panduck

Choose a tag to compare

@teaguesterling teaguesterling released this 30 Oct 21:05
65f03cb

MAJOR. The Pandoc converter leaves this extension for
duckdb_panduck, under the
same names. Nine public names and eleven overloads are gone with no alias path,
so any query using them breaks until panduck is loaded.

"dbu is only supposed to be utility macros." That is the whole reason.

This release is paired, and the pairing is not cosmetic

Install panduck 0.7.0 and this release. One extension must own each name,
and pandoc_ast has an identical signature in both, so the loser throws instead
of overloading. Measured on v1.5.6 with a stock CLI:

Invalid Input Error: Initialization function "<ext>_duckdb_cpp_init" ...
threw an exception: "Failed to add new function overloads to function
"pandoc_ast": function already exists"
combination result
this release + panduck 0.7.0 ok
3.5.1 + the old panduck ok
this release + the old panduck the names are simply absent
3.5.1 + panduck 0.7.0 the second LOAD fails outright

Upgrading only one side is the one combination that breaks hard.

BREAKING — moved to panduck, same names

pandoc_ast_to_blocks            duck_blocks_to_pandoc_ast
read_pandoc_ast                 duck_blocks_to_pandoc_blocks
write_pandoc_ast                pandoc_ast               (table function)
pandoc_inlines_to_db_inlines    pandoc_inlines_to_text          (x2)
duck_blocks_inlines_to_pandoc                           (x2)

Nine names, eleven overloads. LOAD panduck; and the call sites are unchanged.

Worth knowing if you audit the removal yourself: a grep for quoted literals
finds only eight. The ninth, pandoc_ast, was registered through
BlockTypes::ATTR_PANDOC_AST rather than a literal — and it is the only one of
the nine that breaks a LOAD.

NOT changed

  • No spec change. SPEC_VERSION stays 1.4, SPEC_VERSION_SUPERSEDES
    6.6, PREDICATE_REVISION 1.3, so duck_block_spec_version() is
    untouched. This is a release-axis major, not a spec major — the same three
    separate axes 2.0.0's notes set out.
  • ATTR_PANDOC_AST = "pandoc_ast" stays in the vocabulary. It is still a
    block attribute name; only the function registration left.
  • ParseInt32OrDefault stays in pandoc_convert_util.hpp — assembly,
    extraction and validation use it. CollapseLonePlainIntoParent stays;
    duck_blocks_normalize calls it. CheckPandocDepth had no caller outside the
    converter and goes.
  • Three compat helpers are left with no caller on purpose, as generic compat
    code: CompatAddNamedParameter, CompatSetOutputCardinality,
    RegisterTableWithDesc.

Tests

test-require goes from 825 assertions in 16 cases to 757 in 14, and the 68
removed assertions were reconciled against the per-file counts of what was
deleted. Confirmed in CI on this commit, 65f03cb, the v1.5.6 linux_amd64
leg: 757 assertions in 14 test cases, with
require duck_block_utils: FAILED at zero.

The v2.0.0 and v2.0 legs of the same commit read 15 passed, 0 skipped, also
with no require failures. The v1.5.6 arm64 leg builds and does not run
tests — a pre-existing property of that leg, not a gap here — so it is reported
as "no test line" rather than as a pass.

Converter-subject tests moved with the converter. Tests that merely used it as
machinery were rewritten first, in their own commit, with each rewritten input
proven equal to the call it replaced — IS NOT DISTINCT FROM and a
::VARCHAR comparison, for 23 sites in .test files and 3 in
check_conformance_macro.py.

One consequence, stated plainly: those 23 inputs are now frozen literals.
That is deliberate — this extension takes no dependency on panduck, not even
in tests — but they can no longer track a change in the converter's output. They
do not need to; the converter is not this repo's any more. Each carries a comment
naming its source JSON.

The round-trip sweep's render arm never used the converter and stays, as
test/check_render_sweep.py.

Known, pre-existing, not introduced here

make check has the same three failures as before this change: a stale
document RENDER_EXEMPT entry, a validate error-detail mismatch, and
normalize.hpp vendoring.

v3.5.1 — conformance macros accept the document root; nested sublist indent

Choose a tag to compare

@teaguesterling teaguesterling released this 13 Oct 16:08
531b059

Two fixes, both found from outside the code that was wrong. No spec change — SPEC_VERSION stays 1.4, PREDICATE_REVISION stays 1.3, no new constants, no new functions.

The conformance macros refused the document root the spec legalised

vendor/duck_block_conformance.sql and src/validation.cpp are two encodings of one vocabulary, and they disagreed for three releases. The 1.4 amendment (v3.4.0, 2026-09-16) added TYPE_DOCUMENT and made level 0 legal for kind='block' element_type='document' rows and nothing else. The extension implemented it; the macros did neither:

macro was effect
duck_block_declared_types() lacked 'document' a producer emitting the document root was reported by duck_blocks_undeclared_types() as using a name the vocabulary does not declare
duck_block_is_valid() required elem.level >= 1 unconditionally a level-0 document row was invalid by the macros and valid by the extension

The level rule now mirrors src/validation.cpp rather than approximating it. Measured with controls on a plain DuckDB CLI, since the macros are pure SQL and need no build: level-0 document valid; level-0 metadata, level-0 inline document, and level -1 document all still invalid; level-1 heading unaffected; duck_blocks_undeclared_types() clean.

This matters to anyone who vendored the macro file — the bug is in the artifact consumers copy, not in the extension. Under the deferral rule, re-vendoring can wait until you next touch that file.

A consumer found it (duckdb_markdown, while re-vendoring), which is the wrong way round for a defect in two files that both live in this repo. So the release also adds a CI job that compares them: conformance-types needs no build, no network and no DuckDB — two text files and a set comparison — and therefore runs on every push. It was pinned in both directions before being wired: --self-test mutates the pair three ways (a dropped name, an invented name, a truncated scrape) and requires all three to be caught, and the guard was run against the pre-fix macros, where it reports the real historical gap and exits 1.

A nested sublist swallowed every item after it

duck_blocks_render_ansi took a list_item's indent from list_stack.size() - 1, and the loop closing a list whose scope a block had left excluded list_item — so an item could never pop a list. After a sublist, the outer list's next item kept the inner depth and rendered as a child of its own sibling:

- alpha                •  alpha
  - nested one           •  nested one
- beta                   •  beta        <-- one level too deep

The parse was never at fault: beta comes back at level 2, a sibling of alpha. The guard is simply dropped, because the level test alone is the right rule — a container always sits at a lower level than the items it holds, so GetDepth(item) <= back().level is false for an item's own list and true only for lists it has left.

Found downstream in duckeye, where a two-item list with one sublist rendered three bullets at two indents instead of three.

Two assertions, each catching a different wrong fix: the three-line case fails with the guard in place, and the four-line case fails when the pop is an if rather than a while — "pop only the innermost list" passes the three-line case, so that variant was built and measured rather than assumed. Indents are asserted as exact strings rather than LIKE, because the bug moved an indent by exactly two columns and a prefix match would have passed either way.

Also

v3.5.0 is confirmed served, measured on the published artifact rather than inferred: version=e00db69, install_mode=REPOSITORY, and list_contains(duck_block_type_names(), 'document') now true where the previously served artifact returned false.

v3.5.0 — DuckDB 2.0 compatibility, `document` enumerated, the id ruling

Choose a tag to compare

@teaguesterling teaguesterling released this 03 Oct 14:45
e00db69

duck_blocks spec 1.4, amended in place. SPEC_VERSION stays 1.4 and PREDICATE_REVISION stays 1.3: this release adds two constants and one advisory, so no consumer is forced to re-vendor.

DuckDB 2.0 builds again

The v2.0-cyanoptera leg had been red since 2026-09-25, when upstream deleted SimpleNamedParameterFunction and re-based the class:

v1.5.6:      class TableFunction : public SimpleNamedParameterFunction          // carries named_parameters
cyanoptera:   class TableFunction : public BaseTableFunction, public SimpleFunction   // neither does

CompatAddNamedParameter in duckdb_compat.hpp now carries the two pandoc_ast named parameters across both lines, following that header's existing idiom — a member probe, a templated Impl pair under tag dispatch, and both answers pinned by static_assert. On v1.5 it is the identical map assignment reached through a function, so the shipped line is a pure refactor.

Worth recording for anyone porting the same break: AddKeywordOnly is the obvious fix and is wrong. A parameter with no default is required on v2.0, so it would make meta := and api_version := mandatory and break every existing caller — while compiling clean and passing every build check.

document is enumerated

TYPE_DOCUMENT shipped in v3.4.0 and duck_block_type_names() never listed it, so for two weeks the build denied a type this extension emits. The header declared it, the validator accepted it, repair exempted it and the writer dropped it — but a consumer asking the build what types exist was told document does not exist.

duck_block_type_names() now returns 44 names.

id is the document fragment locator

ATTR_ID and ATTR_NAME are declared. Five element types were documented as carrying id and nothing in the header named it, so every consumer spelled the string itself and a changed value would have been silent.

  • id addresses a fragment within a document, as an HTML fragment anchor does. It may be minted by the reader or provided by the source — both are id, because the field says how to address the fragment, not where the string came from. A minted id must be unique within its document, programmatically and deterministically created, and semantic in location and value.
  • name is a different field: what the source called the thing — provenance, not an address. Where no id is supplied, a name may serve as one.

New advisory: a block nested under an inline

duck_blocks_lint now reports a block whose nearest shallower row is an inline — pandoc's Note [Block] transcribed literally. It validates today, and that is the problem: neither IsBody nor the subtree walk distinguishes containment direction, so duck_blocks_body returns the note body and duck_blocks_to_text renders it into the main flow. The footnote's text appears twice and the duplication reads as correct output.

Advisory rather than a refusal: panduck measured zero occurrences across all eleven of their readers, so nothing in the fleet emits it. The conforming shape is an anchor carrying attributes['id'] with the body at document level bearing the matching id.

Also

  • The vocabulary guard gained an arm that needs no compiler, no duckdb and no build, because the arm that would have caught the document gap can only run where a built extension exists — and the CI job that runs it checks out without submodules by design. The skip that hid it is now loud rather than a parenthetical.
  • check_constants_are_used.py masks registration positions ({"id", "children"}, "Build …", make_pair("id", …), named_parameters["meta"]), so silencing a parameter name no longer blinds the scan to the same constant's genuine attribute uses. That revealed six real literals, now using their constants.
  • duck_blocks_lint's ancestor search is O(n) rather than quadratic: the previous backward scan walked to row 0 on every block in a flat document, which is what most markdown is.

Full matrix green on both DuckDB lines: 32 jobs at e00db69.

v3.4.0 — duck_blocks 1.4: the explicit document root

Choose a tag to compare

@teaguesterling teaguesterling released this 22 Sep 00:20
39941a7

duck_blocks spec 1.4, amended in place. SPEC_VERSION stays 1.4 and PREDICATE_REVISION stays 1.3: this release adds one constant and makes a previously-refused shape legal, so no consumer is forced to re-vendor.

The explicit document root

Level 0 is now the optional explicit document root: a kind='block', element_type='document' row standing for the document itself. Everything else still starts at 1, so every document valid before this release is valid after it.

  • Several roots are permitted in one relation, legal wherever they appear. A file may hold more than one root document; a document has exactly one root; file-to-document is usually but not always 1:1.
  • A root carries no content. It is structure. File-scoped facts — a filename, an ordinal, a byte offset distinguishing same-file documents — go in attributes, and the validator rejects content on a root.
  • Still rejected at level 0: a metadata blob, a kind='value' row, any other block type, and every negative level.
  • TYPE_DOCUMENT added to the vocabulary header (97 constants).

The root exists because a consumer whose contract is "these rows are one tree" needs a single root to point at, and prepending one row is cheaper and safer than renumbering levels — shifting every level down by one makes every top-level block a root, which is a different document.

Fixes

  • The Pandoc writers no longer fabricate prose for a root. duck_blocks_to_pandoc_blocks and duck_blocks_to_pandoc_ast share one writer, whose terminal fallback turned any unmapped element_type into a paragraph: an empty root became a blank Para (one per root, which real pandoc accepts and renders as a blank line), and a content-carrying root had its text emitted as document prose. Roots are now skipped. Found by panduck measuring the identical fallthrough in their own writer.
  • Several roots concatenate rather than refuse when converting to Pandoc JSON, which is a single document. The boundary is lost in the output format, not in the relation.

Consumer alignment checker

  • Reads integer constants, not only strings — a stale struct offset was previously invisible.
  • Enforces major equality plus a minor floor: an older same-major minor reads as BEHIND and passes, instead of forcing a fleet-wide re-vendor on every additive change.
  • Compares provenance byte-exactly (both reads are raw bytes; universal newlines previously let a CRLF copy pass).
  • Labels the checkout it actually measured, rather than a sibling directory.

Also

  • Every scalar that can raise an execution error now has a test pinning its error class, so a lost SetFallible() fails the DuckDB 2.0 leg instead of passing silently.
  • duck_block_utils functions are discoverable from duckdb_functions() with descriptions and examples.

Verified

Format-check clean, build clean, full suite green (1356 assertions, 18 files) on the pinned DuckDB d8cdaa33 (v1.5.5), and CI green on the release commit.

v3.3.0 — duck_blocks 1.4: body is a subtree property

Choose a tag to compare

@teaguesterling teaguesterling released this 15 Sep 00:03
95a84e6

duck_blocks spec 1.4, additive on 1.3 (#35).

Body is a subtree property. 1.3 defined body per row, and a per-row predicate cannot see an ancestor: Pandoc-derived readers (docx, odt, org, epub, rtf, tex) emit metadata as a kind='value' container whose text lives in kind='inline' children, so duck_block_is_body said the container was not body and then said "Test Author" under it was. duck_blocks_to_text was clean because it walks the tree; every row filter leaked (panduck's #54 fixture, 2026-09-14). The definition is now:

a row is body  iff  kind IN ('block', 'inline') AND element_type <> 'metadata'
                    AND no ancestor by level is a value or metadata row
  • duck_blocks_body(blocks) -> LIST(duck_block), new: a value or metadata row roots a subtree; it and every following row at a greater level are dropped; the subtree ends at the first row at or above the root's level. Childless value rows and lone frontmatter blobs are dropped whole. A projection: element_order is kept. A scalar over the list, not a table macro (re-scanning a table function through CTE references returned zero rows on DuckDB 2.0, measured by panduck).
  • duck_block_is_body unchanged in its answers, documented as the necessary per-row half.
  • duck_blocks_to_text / to_match_text now level-scope the metadata blob as they do value trees, so to_text(blocks) = to_text(duck_blocks_body(blocks)) holds for a metadata block with descendants too.
  • Validation rule L6: a value tree's descendants sit strictly deeper than their root; an inline that closes a value subtree at exactly the root's level fails with field = 'list'. What validation cannot see is stated: an unindented MetaBlocks child is a block at the root's level.
  • PREDICATE_REVISION = "1.3" in the header: consumer drift checks compare constants by value and cannot see a predicate body; this constant changes when a predicate's answers do (rules in the header comment).
  • check_consumer_alignment reads sitting_duck's (main, SPEC_VERSION x.y) stamp form and reports an unreadable version claim instead of skipping it.

Consumers: re-vendor the header against this tag's commit (a copy on 1.3 reports PREDICATE_REVISION missing until it does). A consumer with native body filters keeps its own walk and adds a gated parity test against duck_blocks_body where both are installed; calling duck_blocks_body from a macro that must work without duck_block_utils would add a runtime dependency.

Verified: v1.5.5 matrix and the v2.0-cyanoptera line green on the PR; suite 1327 assertions / 18 cases; spec alignment OK. Tagged at 95a84e6.

v3.2.0 — duck_blocks 1.3: the body predicate

Choose a tag to compare

@teaguesterling teaguesterling released this 13 Sep 04:51
079123d

duck_blocks spec 1.3, additive on 1.2 (#32).

The body predicate. The document's body, what a text renderer, indexer or embedder should see, is now defined once:

body(kind, element_type) := kind IN ('block', 'inline') AND element_type <> 'metadata'

It is not a kind filter. The verbatim metadata blob (frontmatter, tailmatter, a .yaml read whole) is kind='block' because it has a source position, and it is no more body than the kind='value' tree. Two conformant producers diverged on exactly that element: duckeye's text renderer printed a markdown file's frontmatter above its first heading while the same metadata from a .docx stayed out, and duck_blocks_to_text had the same leak (duckeye and markdown sessions, 2026-09-11).

Carried three ways so they cannot disagree:

  • Header: constexpr bool IsBody(kind, element_type), beside ImplicitParentOf; vendored copies get the rule with the constants.
  • SQL: duck_block_is_body(kind, element_type) -> BOOLEAN, NULL in, NULL out.
  • duck_blocks_to_text / duck_blocks_to_match_text no longer render the blob. This changes their output for a document carrying frontmatter or tailmatter: a fix to the reference tool, recorded in the header's history. raw is body and merely has no text rendering.

Design record: docs/superpowers/specs/2026-09-12-body-predicate-design.md.

Verified: v1.5.5 matrix green; DuckDB-main canary green on all 21 legs, dispatched against the branch before merge. Suite 1273 assertions. Tagged at 079123d.

Consumers: re-vendor the header against this commit and stamp "Vendored at upstream commit: 079123d (SPEC_VERSION 1.3)". A hand-written body filter becomes duck_block_is_body. Nothing else moves; 1.2 consumers are one minor behind, not broken.

v3.1.0 — duck_blocks 1.2: fragments, list-level validation, repair, conformance corpus

Choose a tag to compare

@teaguesterling teaguesterling released this 11 Sep 05:51
6c1c2e5

duck_blocks spec 1.2. The internal 6.x numbering is retired: 1.2 is the former 6.6 with the public label and no shape change (#30). The header records the renumbering in its honest history, marks every earlier entry as the internal line, and publishes SPEC_VERSION_SUPERSEDES = "6.6" so a consumer's major-equality check can tell a renumbering from a break. Next additive bump is 1.3, next breaking 2.0.

Fragments are legal input (issue #29). A list of blocks need not start at a document root. Implicit parents are defined in the header, once, for SQL, C++ and vendored copies alike: list_item -> list, caption -> figure, any inline -> plain; duck_block_implicit_parent(type, kind) reads that table.

List-level validation. duck_blocks_validate now reports rules over the whole list with field = 'list': element_order dense from 0 (L1), shallowest element at level 1 (L2), no level jumps (L3), required ancestors present (L4, L5).

duck_blocks_repair(blocks). The deterministic fixes for those rules, in order: wrap orphans in their implicit parent, rebase levels, collapse jumps, renumber. Idempotent; never changes an element's content, attributes or type, never removes one. The Pandoc exporter repairs a copy before writing, so a fragment exports as a valid document.

Conformance corpus (test/conformance/). Ten constructs with hand-written expected sequences; check_conformance_corpus.py reads each with every installed community producer and reports divergences with attribution. It found real ones on first run (markdown#59, markdown#60) that no repo's own suite could see.

DuckDB main (v2.0 line). duck_block_implicit_parent no longer uses BinaryExecutor::ExecuteWithNulls, which is gone on main (#31). NULL handling is pinned in a non-constant vector, because f(NULL) alone is constant-folded before the function runs.

Verified: v1.5.5 matrix green on #30 and #31; DuckDB-main canary green on all 21 legs, dispatched against the #31 branch before merge. Suite 1238 assertions. Tagged at 6c1c2e5.

Consumers: re-vendor the header against this tag's commit and record the sha in the copy's header comment. markdown (4245b44) and webbed (PR #151) are on 1.2; panduck re-vendoring.