Skip to content

Release 0.20.0: the eighth review (fixes, tests, scaffold, CI, docs) - #150

Merged
tomtom215 merged 117 commits into
mainfrom
claude/ecstatic-noether-8rk1i3
Oct 30, 2026
Merged

tomtom215 merged 117 commits into
mainfrom
claude/ecstatic-noether-8rk1i3

Conversation

@tomtom215

@tomtom215 tomtom215 commented Oct 30, 2026 •

Copy link
Copy Markdown
Owner

Summary

Version 0.20.0, built from an eighth review of the whole repository: twelve reviewers (soundness, the diff since 0.19.0, C API gaps, community-extension conformance, docs, CI and supply chain, hardening, the FFI boundary, two author passes, dependencies, the test suite), then six work packages that fixed what they found, each merged with its own tests. AUDIT.md section 14 has the evidence, what was declined, what is for the owner, and what was not verified. CHANGELOG.md has the entries; Breaking: items are marked inline and "Upgrading from 0.18 to 0.20" in the book lists each with what to do.

Two High-severity defects were found and fixed before release: a segmentation fault in an unpublished ListBuilder optimisation, and SqlMacro::register executing statements ahead of a parse error on DuckDB 2.0.0 (present since before 0.19.0; see Security in the CHANGELOG).

Type of change

  • Bug fix (non-breaking, fixes a specific issue)
  • New feature (non-breaking, adds functionality)
  • Breaking change (existing API changes or removals)
  • Documentation update
  • CI / tooling / dependency update
  • Refactoring (no behaviour change)

Breaking (all in the CHANGELOG): the entry-point macros refuse panic = "abort"; AbiCheck, AbiPolicy, ConfigOptionScope, TlsVersion are #[non_exhaustive]; ScalarBindInfo is no longer RefUnwindSafe; registration is transactional (Registration::Autocommit restores the old behaviour); a zero-argument aggregate no longer registers; generate_scaffold and parse_description_yml refuse inputs they used to accept; libduckdb-sys/duckdb are >=1.4.4, <1.20100 (were <2).

Checklist

Code quality

  • cargo test --all-targets (1,152 pass; 1,293 with duckdb-1-5-4) and cargo test --doc --features duckdb-1-5-4 (235 pass, 3 ignored), run locally on the final tree
  • cargo clippy --all-targets -- -D warnings: default, duckdb-1-5, -3, -4; cargo fmt; cargo doc --no-deps with and without duckdb-1-5-4; typos, taplo, machete, cargo-deny
  • unsafe blocks carry // SAFETY:; SPDX header on new files
  • Some files exceed 500 lines (listed as debt in AUDIT 14.4, e.g. src/copy_function/info.rs)

Testing

  • New code has tests that fail without the fix (the packages' proofs are REPORTED in AUDIT 14.3; I re-ran the ones marked VALIDATED)
  • Mutation testing: the incremental job mutates every changed source file, sharded over eight runners. All eight shards and the gate job pass on the final head. Its blind spots (unsafe fn bodies, literals, macros) are documented in CONTRIBUTING.md.

Documentation

  • Public API documented; CHANGELOG.md updated and the book copy synced (scripts/sync-book-changelog.py --check)
  • Book updated; four new pitfalls (38 in all); scripts/check-release-metadata.py passes

Safety

  • No new panic paths in FFI callbacks; unsafe_op_in_unsafe_fn still denied
  • MSRV 1.86.0 cargo check passes with and without duckdb-1-5-4

What CI confirmed on the final head (7627f84)

CI (pull-request and push runs), Coverage and Mutation Testing all pass. In CI: tests on ubuntu, macOS and Windows (default features, bundled-test, and the duckdb-1-5/-3/-4 feature sets); end-to-end tests against libduckdb 1.4.4, 1.4.5, 1.5.0, 1.5.3, 1.5.4, 1.5.5 and 2.0.0; extension load tests against 1.4.4, 1.5.0, 1.5.5, 1.5.6, 2.0.0 and latest; the hello-ext example and its symbol check on three platforms; WebAssembly (emscripten); Miri (native and big-endian s390x); AddressSanitizer; LeakSanitizer; fuzz smoke; semver-checks; the dependency floor; cargo-deny and OSV; the scaffold end to end; the mdBook build; a publish dry-run.

CI found problems that local runs had not, all fixed on this branch and recorded in AUDIT 14.8: a test that recursed into the engine's type printer and aborted on three platforms; coverage profiles truncated by an ulimit -f test; a Windows race on DuckDB's extension directory; a mutation job that needed more than its 60 minutes (now sharded); a Miri job that needed more than its limit (now 90 minutes); and my own new test files tripping typos and the documented source tree.

The sharded mutation run found 102 surviving mutants, 101 of them in the description.yml reader. They led to four places where the reader disagreed with PyYAML 6.0.3: block-scalar comment lines, an anchor line before a key-level sequence, quoted-key length with spaces before the colon, and a flow-collection key that is not on one line with its : or is over 1,024 characters. Each has a regression test whose expectation is PyYAML's verdict.

Known limits, not fixed

  • The reader still refuses two things PyYAML accepts: a tab-only line inside a block scalar, and a tag alone on a line whose value starts on the next.
  • MAX_TYPE_NESTING (256) bounds quack-rs's own type walks only. DuckDB's type printer recurses too, so an extension that builds types from untrusted input must bound their depth itself (documented on the constant).
  • Miri takes about 79 to 81 minutes of its 90-minute limit on this head (native and s390x legs about 38 to 40 minutes each). The new pure-logic parity tests account for about half; skipping them under Miri is a small follow-up.

For the owner (nothing done)

Yank 0.3.0–0.15.0 and file RustSec advisories; Trusted Publishing and the crates-io environment; the upstream duckdb_register_log_storage double free; Cloudflare email obfuscation; confirm CI passed is the required check. Details in AUDIT 14.5. Dependabot #143, #148, #149 are folded in by hand (#145 earlier) and should close as superseded. DuckDB 2.0.1 is due 2026-11-18; a patch release after it is planned.


🤖 Generated with Claude Code

https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP

claude added 30 commits October 30, 2026 01:55
…und re-reviewing the seventh review

ListBuilder (High, regression vs 0.19.0): the seventh review made
ListBuilder cache its parent's entry array. A builder on a LIST that sits
inside another LIST's child (LIST(LIST(T)), or a LIST field of a list's
STRUCT elements), kept across the outer list's rows, then wrote through a
dangling pointer after the outer list grew, because an outer reserve
reallocates that vector's data buffer (LESSONS L18). The reviewer measured
a segmentation fault on DuckDB 1.5.6 and 2.0.0 and a pass with only the
set_entry line reverted. set_entry fetches the array on every row again,
as 0.19.0 did; the child-writer cache is kept.

append_metadata entry-point note: a Mach-O symbol table spells C symbols
with a leading underscore, so the note fired on every correct macOS build
and advised a rename that would break LOAD. The extension name is now
DuckDB's (the file name up to its first '.', lowercased) and the quoted
error is DuckDB's.

LogicalType: the TIMESTAMPTZ_NS engine check moves from precheck, which
MockRegistrar runs with no DuckDB behind it, into try_new, so the offline
registrar no longer panics; a 1.x development build is judged by the
release it names. VectorWriter::set_null returns early on a vector with no
validity mask, as the C function it replaced did.

Verified so far: lib and bin unit tests (867 and 49) pass with default
features. The new live regression test
(inline_paths::a_list_builder_on_an_inner_list_survives_the_outer_lists_reserves)
was written and validated by the reviewer; I have not yet run it myself,
and I have not yet shown that it fails with list_builder.rs reverted. That
check, and the live suites on 1.5.6 and 2.0.0, are still to do.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
libduckdb-sys / duckdb: ">=1.4.4, <2" becomes ">=1.4.4, <1.20100". libduckdb-sys
numbers DuckDB vX.Y.Z as 1.(10000*X + 100*Y + Z).N, so the new bound admits every
DuckDB 1.4.4 - 2.0.x binding and stops before DuckDB 2.1 (1.20100.0). The old
range admitted bindings this crate cannot be compiled against: libduckdb-sys
1.20000.x keeps the root-level re-exports quack-rs (and the names its exported
macros expand to) behind the default feature `capi-v1`, next to a
"TODO: Remove in the future". The deps reviewer deleted only that re-export from
a copy of 1.20000.1 and quack-rs then failed with 214 errors; a fresh
`cargo add libduckdb-sys` already writes 1.20000.1. Published 0.18.0 and 0.19.0
cannot be narrowed; this only protects new releases.

default-features = false for libduckdb-sys: from 1.20000.x the default features
pull an HTTP/TLS/zip toolchain into every consumer's build (the reviewer measured
67 crates / 36 s CPU against 35 crates / 22 s when both quack-rs and the consumer
turn them off). Up to 1.10506.x those build dependencies are not optional, so it
changes nothing there. `loadable-extension` implies `capi-v1`.

Package: `exclude` (which ships any new top-level file by default) becomes an
`include` allow-list. `cargo package --list --locked` lists 247 files before and
after, which I re-ran: the two examples under examples/*.rs ship, and the
"ignoring example" warning on every package run goes away. cargo-machete ignore
list for `cc` and `criterion`, both used outside the places it looks.

Verified so far: `cargo package --list --locked` = 247 files and Cargo.lock
unchanged. NOT yet verified by me: a build against the 1.4.4 floor and the
1.20000.1 bindings with the lean feature set (a local matrix is running; CI's
dependency-floor, msrv and test-duckdb-2-0 jobs will also exercise it).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…uard.sh (CI-2)

What was wrong: abi-table (two steps), platform-table, spdx-list,
autoload-entries and msrv-vs-duckdb-ci each ran
`python3 scripts/check-X.py || status=$?` and mapped exit 2 to "upstream
unreachable; check skipped". Python itself exits 2 for "can't open file",
so renaming or deleting a guard script left its job green; and on a release
(release.yml calls ci.yml) an upstream outage skipped all six silently.

Evidence (ci reviewer, re-run here): the old inline wrapper around a missing
script printed the "skipped" warning and exited 0.

Change: the ci reviewer's patch 01 (scripts/upstream-guard.sh: refuse a
missing script; 0/1 pass through; 2 is a warning, or a failure when
QUACK_STRICT_UPSTREAM=1, which ci.yml sets when github.ref_type is 'tag').
Added on top: `upstream-guard.sh --self-test` (9 cases on stub scripts:
exit 0/1/2/3, strict and not, missing script), run by the `doc` job, so the
mapping is itself under test.

Ran: shellcheck 0.11.0 clean; self-test 9/9; five mutants of the wrapper
(no exists-check, strict ignored, 2 -> fail, status not passed through,
`|| true` on the python call) each turn the self-test red; the six real
guards through the wrapper: abi-table, api-coverage, platform-table,
spdx-list, msrv-vs-duckdb-ci exit 0, autoload-entries exit 0 with the
"skipped" warning after a transient "Remote end closed connection" (the
case exit 2 is for); a missing script exits 1 with ::error::. actionlint
1.7.12 clean on ci.yml (-ignore SC2129). Not run: the workflow on GitHub.
…e coordinator's main-branch fix)

DuckDB 2.0.0 rejects the arrow lambda `j -> [...]` by default (Binder Error:
Deprecated lambda arrow), so
a_list_builder_on_an_inner_list_survives_the_outer_lists_reserves could not
run on 2.0.0. Same one-line text change the coordinator committed on the main
branch (`lambda j: ...`, accepted by 1.4.4, 1.5.6 and 2.0.0), applied here so
the cross-engine run of inline_paths (finding list item 8) can use it and the
merge is clean.
…I-7)

What was wrong: four mutations of ci.yml that remove a gate kept the
`ci-ok` aggregate check green (ci reviewer, mutation probes agg-6..agg-10):
a job demoted with `continue-on-error: true` and dropped from `needs`, a
step-level `continue-on-error` in a blocking job, the ci-ok body gutted
with the checked pattern kept in a comment, and a new job declared with a
YAML anchor or trailing comment (invisible to the parser). Nothing checked
the README's gate table, which is documented as generated.

Change: the ci reviewer's patch 02 (explicit INFORMATIONAL and
INFORMATIONAL_STEPS sets; job ids with a trailing comment or anchor;
comment-stripped safety patterns; the README table must list exactly
ci.yml's jobs and kinds). One hole found reviewing it: step-level
`continue-on-error` was checked only in `blocking` jobs, which excludes
`ci-ok` itself, so `continue-on-error: true` on the aggregate's own step
made "CI passed" green whatever its needs did. The step check now covers
every non-informational job, ci-ok included. Regexes named, `l` renamed
(ruff E741/E501), docstring lists every check.

Ran (copy-based runner, $S/impl/infra/mut_aggregate.py; never edits the
tree): baseline green (35 blocking jobs); 17 gate-removing probes RED
(the reviewer's agg-1..13 plus agg-15 ci-ok step continue-on-error,
agg-16 README row dropped, agg-17 README kind wrong, agg-18 job-level
continue-on-error on ci-ok); false-positive probe agg-14 (`fuzz: # smoke`)
GREEN. agg-15 against patch 02 as written: GREEN (the hole), with the fix:
RED. ruff clean (default and E,F,W).
CI run 701 (the previous commit) failed the blocking "Test against DuckDB
v2.0.0" job: the new regression test for the ListBuilder entry-array fix
compared its output with `list_transform(range(x % 7), j -> [...])`, and
DuckDB 2.0.0 rejects the arrow lambda by default ("Binder Error: Deprecated
lambda arrow (->) detected"). The code under test was not at fault: the other
394 live tests passed on 2.0.0. I had not run the test on 2.0.0 before
committing it; the previous commit message said so.

`lambda j: ...` is accepted by 1.4.4, 1.5.6 and 2.0.0 (checked by running the
oracle expression in each CLI). No other arrow lambda occurs in the repository's
tests, book, README or examples (grep).

Verified: the four inline_paths tests pass live on DuckDB 1.5.6 (4 passed).
NOT yet confirmed by me: the live run on 2.0.0 (queued behind another build on
the shared lock); CI's "Test against DuckDB v2.0.0" job will be the check.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…after the whole CI run (CI-1, CI-15)

What was wrong: release.yml packages and publishes with `--locked`, but
nothing before the `package` job checked that Cargo.lock names the
version Cargo.toml was bumped to: `validate` checks only Cargo.toml and
the CHANGELOG heading, and ci.yml's publish-dry-run ran
`cargo publish --dry-run --allow-dirty`, which quietly rewrote the lock.
A release commit made by RELEASING.md's steps (which said not to touch
Cargo.lock) passed validate and all of ci.yml and failed `cargo package
--locked` afterwards (ci reviewer, VALIDATED on a scratch bump). Other
release metadata (CHANGELOG links, CITATION.cff, SECURITY.md row, README
"latest" line, `quack-rs = "0.X"` snippets) was checked by nothing.

Change: the ci reviewer's patch 03, minus its RELEASING.md part (merged
by hand with the docs and harden reviewers' text in a later commit):
scripts/check-release-metadata.py, run by the `doc` job and by release.yml
`validate`; publish-dry-run is `cargo publish --dry-run --locked`.
Extended: the check covers every committed lockfile that records quack-rs
(root, examples/hello-ext, fuzz, book/doctest; benches/engine once it is
committed), not only the root one. `validate`'s lightweight-tag error no
longer claims the job checks signatures (CI-15).

Ran: the check on this tree: agrees (0.19.0). On a copy with only
Cargo.toml bumped to 0.20.0: exit 1, 25 places, including all four
lockfiles. After `cargo update --workspace --offline` in three of the
four lockfile dirs: exit 1 naming only fuzz/Cargo.lock; each updated
lockfile differs from the original by exactly the quack-rs version line.
ruff clean; actionlint clean; check-ci-aggregate and
check-workflow-expressions green.
…t; reset draft/prerelease on edit (CI-6, HARDEN-11, CI-9)

What was wrong: (CI-6 = HARDEN-11) `publish` re-packaged after the manual
approval, uploaded, and only then compared crates.io's .crate with the
SHA256SUMS the `package` job attested: a mismatch could only be reported
once the version was live and irreplaceable. (CI-9) When a GitHub release
already existed, `gh release edit` never cleared `--draft` and only ever
added `--prerelease`, so a draft stayed invisible and a wrong prerelease
flag stayed.

Change: the ci reviewer's patch 04, taken as the single implementation of
the pre-upload check (the harden reviewer's patch 09 does the same but
downloads the artifact into the checkout, where `cargo package` counts it
as an uncommitted change and would include it; declined). `package`
records `rustc --version`; `publish` installs that rustc, downloads the
attested artifacts to $RUNNER_TEMP, runs `cargo package --no-verify
--locked` before any credential step and stops unless the sha256 equals
SHA256SUMS; the post-publish crates.io check reads the same file.
`gh release edit --draft=false` and `--prerelease` / `--prerelease=false`
both ways; upload-artifact `overwrite: true` for a whole-workflow re-run.
Added: the step also refuses when this job's `rustc` is not the recorded
one. dtolnay's action only sets rustup's default, which rust-toolchain.toml
overrides, so the `toolchain:` input alone did not guarantee it; the
comment said it did.

Ran: the step's run block, extracted from this release.yml with PyYAML,
in a clone of the v0.19.0 release commit (9c2dc76, = refs/tags/v0.19.0^{}
by git ls-remote) with RUSTUP_TOOLCHAIN=1.99.1: crates.io's own hash
(1d806ed0..., sha256 of the downloaded quack-rs-0.19.0.crate) -> exit 0,
packaged hash identical; tampered SHA256SUMS -> exit 1; recorded rustc
1.98.0 -> exit 1; empty recorded rustc -> exit 1; SHA256SUMS naming
another file -> exit 1. actionlint clean, check-workflow-expressions
green. `gh release edit --help` (gh 2.89.0) documents `--draft=false`.
Not run: the job on GitHub, the environment approval, Trusted Publishing.
What was wrong: ChunkWriter::next_row claims a row (returns its index and
counts it) and the drop publishes every row counted, but the docs called the
count "rows written". The natural loop over a source of unknown length,
`while let Some(row) = cw.next_row() { let Some(v) = src.next() else { break };
... }`, claims one row it never writes, and that row is published holding
whatever DuckDB's reused output chunk last held. Reviewer `unsound` validated a
wrong answer on 1.5.6 (stale 7 from the previous scan call); for a LIST/MAP
column written by hand the stale {offset, length} entry is a conjectured
out-of-bounds read.

What changed:
- `ChunkWriter::release_row(row)` gives back the most recently claimed row, so
  the drop does not publish it; the next `next_row` returns the same index.
  The row is named, not implied, so giving back the wrong one is loud: any row
  but the last claimed one panics with a message naming the row that could be
  given back (`# Panics`; the callback macros turn it into a SQL error).
- Module, struct, `next_row`, `row_count` and `DataChunk::into_chunk_writer`
  docs now say "claimed", spell out the hazard, and show the source-runs-out
  loop with `release_row`. The drop cannot know whether the last claimed row
  was written (writes go through VectorWriters that do not report back), so
  it asserts nothing; the struct docs say so.

Tests:
- unit: release_row_gives_back_the_last_claimed_row,
  release_row_refuses_any_row_but_the_last_claimed_one.
- live: chunk_writer::a_claimed_row_the_source_cannot_fill_is_given_back_not_published_stale
  reproduces the reviewer's probe (scan 0 fills a chunk with 7, scan 1 claims
  three rows from a two-item source). 1.5.6: passes. Against 734bb15's
  src/chunk_writer.rs (no release_row; the test's release line replaced by
  `let _ = row;`, the only thing 734bb15 allows) it fails:
  `[1, 2, 7] left: 2051 right: 2050`. The test also pins the hazard the docs
  describe (no release: tail [1, 2, 7]).
What was wrong: no workflow linter ran in CI. The workflows README said
actionlint "cannot be checksum-pinned the way osv-scanner is"; the release
publishes actionlint_<version>_checksums.txt. check-workflow-expressions.py
covers only empty/unclosed expressions: `${{ x == }}` passed it.

Change: the ci reviewer's patch 05: a blocking `workflow-lint` job
(actionlint 1.7.12 from the release tarball, sha256-verified; fails if
shellcheck is missing, because actionlint then skips every run: block
silently; SC2129 ignored as style), in ci-ok's needs, the README gate
table and the ci.yml header; README paragraph corrected.

Ran: `git ls-remote --tags rhysd/actionlint`: v1.7.12 is the newest tag.
The release's actionlint_1.7.12_checksums.txt linux_amd64 line, the pin
in ci.yml and the downloaded tarball's sha256 are all 8aca8db9...a3d8; the
install step, extracted from ci.yml, run verbatim: `actionlint.tar.gz: OK`,
version 1.7.12. actionlint as the job runs it, over all six workflows:
clean. On a copy with `echo ${{ needs.nonexistent.outputs.version == }}`:
check-workflow-expressions exit 0, actionlint exit 1 ("unexpected end of
input ... [expression]"). The shellcheck guard with shellcheck off PATH:
exit 1 with ::error::. check-ci-aggregate: 36 blocking jobs.
READ, not run: the ubuntu-24.04 runner image lists shellcheck 0.9.0-1
(actions/runner-images Ubuntu2404-Readme.md, image 20261026.354.1); I ran
0.11.0 locally, so the runner may report a slightly different set.
…build it (CI-13)

What was wrong: examples/hello-ext is its own Cargo workspace (no
[workspace] in the root manifest), and Swatinem/rust-cache caches only
the root workspace's target/ unless told otherwise, so example-check (x3),
symbol-check (x2) and extension-load (x6) rebuilt hello-ext's dependency
tree and quack-rs with fat LTO on every run (ci reviewer; 81 s cold
locally under load).

Change: the ci reviewer's patch 06: `workspaces: ". -> target" and
"examples/hello-ext -> target"` on those three jobs' rust-cache step.

Ran: actionlint clean. READ: rust-cache's src/config.ts at the v2.9.3 pin
(d1527c8) splits the input on newlines and resolves `$root -> $target` as
path.join(root, target), i.e. examples/hello-ext/target.
CONJECTURED, not measured: the time saved (cache hit rates cannot be read
from here). The fuzz/ and book/doctest/ targets stay uncached.
What was wrong: `cargo test scaffold_generated_code_compiles -- --nocapture`
compiles every test target and runs the filter in each; `cargo test
<filter>` exits 0 when nothing matches, so renaming the test would have
left the job green with nothing run (ci reviewer: `...compilez` ->
`running 0 tests ... 71 filtered out`, exit 0).

Change: the ci reviewer's patch 07 (`--test integration_test ... --exact`,
output tee'd), with the check tightened: the libtest summary line must
read `test result: ok. 1 passed;` rather than grepping for the
`test ... ok` line, which a test that printed under --nocapture would
split. Comment corrected (the old form ran the one test, in one of nine
binaries).

Ran: the new grep against libtest output: the reviewer's --exact run
log (`1 passed`) exit 0, the zero-test log (`0 passed ... 71 filtered
out`) exit 1. The test is top-level in tests/integration_test.rs and
captures its child cargo's output (`.output()`), so --exact matches it and
it prints nothing on success (read). actionlint clean.
Not yet run by me: the cargo test command itself (disk below the 4 GB
floor at the time; see the impl report).
….0 behaviour fixes, tutorial on guarded callbacks

What was wrong (eighth review, docs/deps/author reviewers; each re-verified before writing):
- README clipped code at ~64 columns on crates.io, had no maintenance / help /
  link row, and several ambiguous sentences (DOCS-9). Adopted patch 03 line by
  line; cut nothing the patch added except the "audited" seal in the tagline
  (the Status section says audits keep finding defects).
- README claimed "no C, no C++, no glue code" (DEPS-11). True: the repository
  holds Rust only. Not true: `cargo tree` shows `ring` (C) in the default
  libduckdb-sys graphs; the bundled-test features compile C/C++; the community
  flow needs Python and git. README and Installation now say so.
- libduckdb-sys range `>=1.4.4, <2` admits bindings that would not compile
  (DEPS-2). Every snippet and sentence now shows `>=1.4.4, <1.20100`, with
  default-features = false, and Installation explains the upper bound, what to
  do when 1.20100 appears, and `cargo tree` counts measured here (1.20000.1:
  65 crates default vs 30; 1.10506.0: 74 vs 72). All `quack-rs = "0.19"`
  snippets are "0.20".
- DuckDB 2.0.0 contradicts three documented behaviours (DOCS-3), measured on
  1.4.4/1.5.6/2.0.0: interval '1 month'-'1 day' vs '29 days' (eq/gt flip),
  bare-identifier table macro argument warns, VerifyNullHandling is compiled
  into release builds in 2.0.0 and runs only after
  SET debug_verification_mode='VERIFY_FUNCTIONS' (INTERNAL Error observed).
- arg_max 3-argument signature is (ANY, ANY, BIGINT) on all three engines.
- publishing.md printed `...yml@v2.0-cyanoptera`, which Cloudflare rewrites to
  "[email protected]" on the live site (DOCS-6); reworded without the @.
  Also: the v1.5.6 branch of extension-ci-tools is not the commit of v1.5-variegata.
- "Your First Extension" taught unguarded raw callbacks and an aggregate that
  segfaults under OVER () with no warning (DOCS-4). Rewritten on
  aggregate_*_callback! and map1_str, with a warning callout listing the shapes
  that crash. Built from the page's visible code and run on 1.4.4, 1.5.6 and
  2.0.0: output byte-identical to the page. Window shapes re-run on the three
  engines (5000 and 300000 rows, one process per shape): OVER (), explicit
  ROWS/RANGE UNBOUNDED..UNBOUNDED frames (also with PARTITION BY) and
  agg(x ORDER BY y) segfault on 1.4.4 and 1.5.6; OVER (PARTITION BY p) without
  ORDER BY segfaults on 1.4.4 only; all pass on 2.0.0.

Ran: book doctest first_extension filter, 13 passed (live 1.5.6).
… bounds (FFI-1)

What was wrong: data_chunk_from_arrow's layout walk read a list's first and
last offset and used (first, last - first) unchecked. A negative first
offset, a last offset past the child, or offsets that decrease (also in the
middle, where both ends look fine) were accepted; DuckDB imports the child
zero-copy and reads it out of bounds once the chunk is read (reviewer `ffi`:
SIGSEGV on 1.5.6 and 2.0.0, valgrind invalid read). `last - first` was
unchecked i64 arithmetic ([i64::MIN, 0] panics under overflow checks).

Checked the same class elsewhere (DuckDB arrow_conversion.cpp read at
v1.5.6 and v2.0.0):
- LARGE_LIST (+L) and MAP (+m) share the list path: same defect. At 734bb15
  a +L [-6,-2] was refused only by a DuckDB INTERNAL cast error, and a map
  past its child was "refused" by DuckDB's map verification after it had
  already read 9 keys from a 4-element buffer.
- LIST_VIEW: negative offsets/sizes passed (DuckDB reads them unsigned).
- FIXED_SIZE_LIST, struct fields, union members: a child shorter than the
  rows its parent reads was never compared with its length (top-level
  columns only).
- dictionary indices: DuckDB builds the selection from them unchecked
  (SetSelectionVectorLoop), so an index past the dictionary is read past it;
  quack-rs's own flatten then copies through it.

What changed (new src/arrow/import_layout/bounds.rs):
- list_range reads every offset of the rows DuckDB reads and refuses a
  negative one, a decrease, or an end past the child, with checked
  arithmetic; used for +l, +L and +m.
- list_view_entry refuses a negative list-view offset or size.
- covers refuses any node shorter than inherited + size rows (struct field,
  list/fixed-size-list child, union member).
- dictionary_indices refuses an index outside 0..dictionary length in every
  row DuckDB uses (rows NULL in the indices' own bitmap with null_count > 0
  are skipped, as DuckDB masks them); Shape records the index type from the
  schema format. A row NULL only in an enclosing struct must still hold a
  valid index, as the Arrow spec requires of every non-NULL index.
- data_chunk_from_arrow's # Errors lists the new refusals.

Tests:
- unit (src/arrow/import_layout/tests.rs): list_offsets_outside_the_child_are_refused,
  negative_list_view_offsets_or_sizes_are_refused,
  a_child_shorter_than_its_parent_reads_is_refused,
  dictionary_indices_outside_the_dictionary_are_refused,
  index_formats_map_to_their_integer_types; every pre-existing layout test
  still passes (52/52). Mutation: reverting the list hunk to 734bb15's two
  reads, removing covers, list_view_entry or the index check each fails its
  test.
- live: arrow_layout::list_offsets_and_indices_outside_their_child_are_refused_before_duckdb_reads_them
  (hand-built +l/+L/+m/+w:3/dictionary arrays, each beside a valid
  neighbour that must import with the right values). 1.5.6: 44/44 arrow
  live tests pass. With 734bb15's src/arrow/import_layout.rs: the test
  binary dies with SIGSEGV (signal 11); a non-reading probe of the same
  cases shows 734bb15 accepted the +l -5, past-child and decreasing
  offsets, the short fixed-size-list child and the out-of-range index.
… latest stable (CI-3)

What was wrong: rust-toolchain.toml said `channel = "stable"` and 31 jobs
installed `toolchain: stable`, with RUSTFLAGS `-D warnings` and clippy's
pedantic/nursery groups enabled: any Rust release (every six weeks; 1.100
is due about 2026-11-12) could turn every job red with no change here, as
1.99.0's `assert_is_empty` already did once (AUDIT.md 12.7).

Change (the ci reviewer's patch 09, adopted by the maintainer's decision,
with changes):
- rust-toolchain.toml `channel = "1.99.1"`; every `toolchain: stable` in
  ci/release/docs/mutants/coverage/benchmarks.yml -> `1.99.1` (32 pins),
  test-bundled-duckdb-2-0 included (it is informational for build time,
  not to track Rust). MSRV (1.86.0), nightly and beta jobs unchanged.
- New informational `latest-stable` job: `toolchain: stable`,
  RUSTUP_TOOLCHAIN=stable over the toolchain file (so rust-cache's key uses
  it too), fmt --check, clippy -D warnings (default and duckdb-1-5-4),
  rustdoc, lib tests, all `cargo +stable`. continue-on-error, outside
  ci-ok, in check-ci-aggregate.py's INFORMATIONAL set and the README table
  ("the four marked informational").
- `security` now installs the pinned toolchain explicitly: it had none and
  relied on rustup installing what rust-toolchain.toml names on demand (on
  by default since rustup 1.28.1, but an image can turn it off).
- scripts/check-toolchain-pin.py rewritten job-aware: patch 09's version
  read only `toolchain:` inputs, rejected `stable` everywhere (so a latest-
  stable job could not exist) and passed expressions and `cargo +X` /
  `RUSTUP_TOOLCHAIN` unseen. Now every reference is checked: pin, MSRV,
  nightly (dated allowed), stable/beta only in informational jobs,
  run-time values only in the two listed (release.yml publish,
  ci.yml scaffold-e2e). Run in the `doc` job.
- ci.yml header and three comments that said the file pins "stable";
  release.yml package comment.

Verified: `rustc +1.99.1 -vV` = 1.99.1 (58cf8f9c3 2026-10-13); the rust
dist channel-rust-stable.toml (date 2026-10-15) and channel-rust-1.99.1.toml
name the same commit; dtolnay/rust-toolchain's action.yml (READ at
683b588 and e2a55d2, identical) passes `1.99.1` verbatim to
`rustup toolchain install` and runs `rustup default`, which a toolchain
file overrides (hence `cargo +stable` / RUSTUP_TOOLCHAIN in the new job);
the ubuntu-24.04 image (runner-images readme, 20261026.354.1) ships Rust
1.99.1 and rustup 1.29.2. Mutation probes ($S/impl/infra/mut_toolchain.py):
12 RED as expected (stable in a blocking job via input / `cargo +` /
RUSTUP_TOOLCHAIN env / `rustup run` / workflow env; toolchain file back to
stable, not exact, bumped alone; an older pin; an unlisted `$var`;
latest-stable losing continue-on-error; release.yml package on stable), 2
GREEN as expected (dated nightly; a comment). actionlint clean;
check-ci-aggregate 36 blocking; zizmor 50 -> 52 findings, the two new
dtolnay uses (pedantic superfluous-actions), default-visible unchanged.
Not run: any job on GitHub; the latest-stable job's commands on 1.100
(the ci reviewer ran clippy on 1.100.0-beta.7 clean).
… against the workflows (DEPS-15)

What was wrong: Dependabot #145 bumps three actions. Merged as is, it
would (1) leave all 39 dtolnay/rust-toolchain lines commented
`# master 2026-10-08` on a 2026-10-15 commit, and the ci.yml header naming
the old commit; (2) leave the scaffold's own copies of the pins
(src/scaffold/templates_ci.rs) on the old commits: nothing compared them
with .github/workflows, so generated extension CIs would silently keep
older actions (deps reviewer, DEPS-15).

Change, every workflow:
- Swatinem/rust-cache v2.9.2 -> v2.9.3 = d1527c8f67ef9af357290475d4af4b0fab8f12e0 (35 uses)
- rust-lang/crates-io-auth-action v1.0.5 -> v1.0.6 = 3268eb413133e2960fa4ae0e963ca76380c54cd9
- dtolnay/rust-toolchain -> 683b588c487a69d01f6c6ddf40f036ff682cc2c8 (master HEAD,
  2026-10-15), commented `# master` (41 uses): the branch has no tags and
  Dependabot moves the commit, so a date in the comment goes stale.
- ci.yml header reworded so it stays true across those bumps.
- scripts/check-action-pins.py, in the `doc` job: every remote `uses:` is a
  40-hex commit; each action repository is pinned one way across all
  workflows (commit and the comment's first word); each pin in
  templates_ci.rs that names an action the workflows use must match; no
  pins found on either side is an error.
- dependabot.yml: hello-ext gets no duckdb/libduckdb-sys ignore, on
  purpose, and says why: the example tracks the newest bindings (2.0's),
  unlike the MSRV-held root lock, and is where CI builds and loads them.

Verified: `git ls-remote`: rust-cache refs/tags/v2.9.3^{} = d1527c8,
crates-io-auth-action refs/tags/v1.0.6 = 3268eb4, dtolnay HEAD and master =
683b588. Upstream diffs read (shallow fetches): rust-cache 2.9.2..2.9.3
action.yml unchanged, src/ has three fixes (await, `return`->`continue` in
timestamp pruning, a warning -> info), dist/ rebuilt (not rebuilt by me);
crates-io-auth-action 1.0.5..1.0.6 action.yml unchanged, dependency/CI
updates and dist/ rebuild; dtolnay e2a55d2..683b588 is one line in
scripts/update-revs.sh (e2a55d2 is an ancestor). check-action-pins.py:
on this branch alone exit 1, naming exactly the two stale scaffold pins
(RUST_TOOLCHAIN, RUST_CACHE) with the strings to use; on a copy with
them updated: exit 0, 139 uses, 12 repositories; probes (copy-based,
$S/impl/infra/mut_pins.py): one use on another commit, a stale version
comment, a floating tag, a scaffold pin differing, templates_ci.rs pins
no longer parsing, release.yml on a tag -> all RED; a date after
`master` and cache/restore+save -> GREEN. dependabot.yml validates
against SchemaStore's dependabot-2.0 schema (jsonschema 4.26.0; 4 blocks,
cooldown on all 4); a copy with a bad cooldown and an unknown key is
rejected. actionlint clean; zizmor unchanged (52, default-visible 2).
…EN-7)

Adopted from reviewer `harden`'s patch 04, line by line (all of it is in
src/scalar/**, src/table/** and tests/**; nothing in src/query or src/value).

HARDEN-6: collision::type_string, signature::describe and
type_check::contains_type recursed on a logical type with no bound; a LIST
of LIST ... a few thousand deep (as a reader of an untrusted schema builds)
overflowed the stack and aborted the process. MAX_TYPE_NESTING (256) bounds
all three: type_string returns None (not rendered, not checked),
describe writes "...", contains_type counts it as a match (every caller
uses the answer to refuse something).

HARDEN-7: BindInfo::set_cardinality(u64::MAX, _) made any join with the
function fail with "INTERNAL Error: Information loss on integer cast" on
1.5.6. The hint is clamped to i64::MAX, documented.

Changed from the patch:
- hostile_input::a_deeply_nested_type_is_refused_not_recursed_into also
  registers a two-overload scalar set 3,500 levels deep, so describe's cap is
  tested: the patch's 2,000 levels do not overflow describe's smaller frame.
  At 3,500, with 734bb15's signature.rs alone, the test aborts with a stack
  overflow whose gdb backtrace is quack_rs::scalar::builder::signature::describe
  frames; with the cap it passes. At 6,000 levels DuckDB's own
  LogicalType::ToString overflows the same 2 MiB thread (gdb: ToString
  frames, during a later catalog scan), so MAX_TYPE_NESTING's docs now say
  the cap protects quack-rs's walks only.

Evidence (1.5.6, live): hostile_input 5/5 pass. With 734bb15's collision.rs,
signature.rs, type_check.rs and info.rs: a_deeply... dies with SIGABRT
("thread has overflowed its stack"), an_enormous_cardinality... fails with
"INTERNAL Error: Information loss on integer cast: value
18446744073709551615 ...".
…e CI-only graphs; hello-ext publish = false (DEPS-4, DEPS-5, DEPS-6)

What was wrong (deps reviewer): no typos config (every finding a false
positive), no taplo config, no .editorconfig; deny.toml cannot be applied
to the hello-ext, fuzz and book/doctest graphs (unused-allowed-license is
"deny"; libfuzzer-sys is "(MIT OR Apache-2.0) AND NCSA"; the doctest and
bench crates have no license), so those graphs had no license/ban/source
gate at all; deny.toml listed `sparse+https://index.crates.io/`, a form
Cargo.lock never records (an `unmatched-source` warning every run);
unmaintained/unsound defaulted to direct dependencies only; wildcards only
warned; examples/hello-ext lacked `publish = false` (fuzz, doctest and
benches have it).

Change: the deps reviewer's patch 0001, files I own only: typos.toml,
.taplo.toml, .editorconfig, deny.ci-crates.toml, the deny.toml changes
(unmaintained/unsound "all", wildcards "deny" with allow-wildcard-paths,
the one registry form), hello-ext `publish = false`.
Not taken: the root Cargo.toml hunks (the `include` allow-list and
[package.metadata.cargo-machete]) and book/doctest/Cargo.toml's machete
metadata: the coordinator owns those files; the hunks are handed over in
the impl report, and the `hygiene` job's machete step needs them. The
justfile: declined, a third hand-kept copy of the gate commands
(CONTRIBUTING.md and ci.yml are the others) with nothing checking it,
the drift this repository already had with the README gate table and
RELEASING's job list. docs patch 02's `_typos.toml` is the same idea; this
`typos.toml` uses narrower regex ignores, and only one of the two should
exist (typos reads one).

Ran: typos 1.46.0 exit 0 on this tree; a planted `recieve` exit 2; with
typos.toml removed 64 findings. taplo 0.10.0 fmt --check and lint exit 0
over 14 TOML files; a misformatted Cargo.toml line exit 1. cargo-deny
0.20.2: root `check` advisories/bans/licenses/sources ok, no
unmatched-source warning (8 duplicate-version warnings remain);
hello-ext, fuzz, book/doctest with --config deny.ci-crates.toml: all four
ok; the same three with the old deny.toml: licenses FAILED (exit 4).
cargo-machete 0.9.2 --with-metadata: flags cc, criterion (root) and the
doctest crate's libduckdb-sys/proptest/quack-rs (false positives: build.rs,
a [[bench]], generated doctests); on a copy with 0001's two manifest
hunks applied: clean, and typos/taplo stay clean.
… the CI-only graphs (DEPS-4, DEPS-6)

What was wrong: CI ran cargo-deny on the root graph only; hello-ext, fuzz
and book/doctest were read by the OSV job and nothing else, and
benches/engine (lockfile gitignored) by neither. No spelling, TOML-format
or unused-dependency check ran.

Change: the deps reviewer's patch 0003, by hand on this branch's ci.yml:
- `security` runs `cargo deny --config deny.ci-crates.toml check` on
  hello-ext, fuzz, book/doctest, and on benches/engine once its lockfile
  exists (grouped per crate).
- `osv-scan` builds its --lockfile list in bash and adds
  benches/engine/Cargo.lock when present (the coordinator commits it),
  under `set -euo pipefail`.
- New blocking `hygiene` job: typos 1.46.0, taplo 0.10.0, cargo-machete
  0.9.2 as release binaries pinned by SHA-256 (curl --retry 5), then
  `typos`, `taplo fmt --check`, `taplo lint`, `cargo machete
  --with-metadata`; in ci-ok's needs, the README table and the header.
  On the pinned toolchain.

Pins re-verified: `git ls-remote` shows tags typos v1.46.0 (newest is
v1.51.1; kept, the config was validated against 1.46.0), taplo 0.10.0
(= release-taplo-cli-0.10.0), cargo-machete v0.9.2 (newest). cargo-machete
publishes a .sha256 per asset: 48200087... = the pin = the downloaded
asset. typos and taplo publish no checksum file (probed four names each:
404), so their pins equal the assets GitHub serves today, as the job's
comment says (trust on first use).

Ran (steps extracted from this ci.yml with PyYAML, executed verbatim on a
copy): hygiene install: three `OK` lines, versions 1.46.0 / 0.10.0 /
0.9.2; typos, taplo fmt --check, taplo lint exit 0; cargo machete exit 1
on this branch alone (the cc/criterion and doctest false positives) and 0
with deps 0001's two [package.metadata.cargo-machete] hunks applied: those
are in Cargo.toml and book/doctest/Cargo.toml, which the coordinator owns
(handed over in the impl report). osv-scan install `osv-scanner: OK`;
scan of the 4 lockfiles "No issues found"; with a benches/engine/Cargo.lock
generated by cargo 1.99.1 (libduckdb-sys 1.20000.1) 5 lockfiles, "No
issues found". CI-crates deny step: 3 graphs ok; with the bench lockfile 4
graphs ok. actionlint clean; check-ci-aggregate 37 blocking jobs.
…PS-6)

What was wrong: clippy.toml set too-many-lines-threshold = 100 with the
comment "Set to 100 to accommodate FFI registration methods", but 100,
7 and 25 are exactly clippy's defaults, so the file changed nothing and
the comment implied a relaxation that does not exist (deps reviewer).

Change: comments only. The values stay, written down so a future clippy
changing a default does not silently change the bar; the file says so.

Verified: clippy_config/src/conf.rs at tag rust-1.99.0 (raw.githubusercontent):
cognitive_complexity_threshold = 25, too_many_arguments_threshold = 7,
too_many_lines_threshold = 100. taplo fmt --check and typos clean.
…T2-1)

What was wrong: the duplicate-overload guard (signature.rs, used by the
scalar and aggregate set builders) and the catalog collision check
(collision.rs, single and set registrations) compared parameter types
structurally, so DECIMAL(4,1)/DECIMAL(18,3), MAP(VARCHAR,BIGINT)/
MAP(BIGINT,VARCHAR) and two ENUMs counted as distinct overloads, also nested
in LIST/ARRAY/STRUCT. DuckDB's CastRules::ImplicitCast (read at v1.4.4,
v1.5.6, v2.0.0) compares those by type id alone (cost 0 either way), so it
registers the set and fails every call with "Could not choose a best
candidate function" (reviewer `author-types`, VALIDATED on all engines).
It also matches named STRUCT fields by name, in any order and case.

What changed:
- signature.rs: a Render mode. Render::Overload renders DECIMAL/MAP/ENUM by
  type id, lower-cases and sorts named STRUCT fields and UNION members
  (positional when a name is empty), recursing through LIST/ARRAY/STRUCT/
  UNION; the guard compares those keys and reports the exact renderings,
  adding OVERLOAD_RULE (why they collide) when the exact types differ.
- collision.rs: the catalog check compares overload_key(rendered), which
  reduces DECIMAL(w,s) and MAP(k, v) to DECIMAL / MAP at any depth, so
  round(DECIMAL(18,3)) beside the built-in round(DECIMAL) is refused.
- Set/single builder docs state the rule. Documented as not detected (read
  from the source, not run): LIST(T) beside ARRAY(T, n), and a UNION whose
  members are a subset of another's (both asymmetric zero-cost casts).

Tests:
- unit: overload_keys_ignore_decimal_and_map_parameters,
  check_refuses_signatures_duckdb_resolves_by_type_id_alone,
  members_sort_by_name_only_for_the_overload_key_of_a_named_type.
- live (tests/ffi_roundtrip/overload_keys.rs, 4 tests): eight refused scalar
  pairs (DECIMAL, MAP, ENUM, LIST(DECIMAL), ARRAY(DECIMAL,2), STRUCT(DECIMAL),
  LIST(MAP), STRUCT field order/case), an aggregate DECIMAL pair, the catalog
  round(DECIMAL(18,3)) and a MAP re-registration; five distinct pairs (INT/
  BIGINT, LIST(INT)/LIST(VARCHAR), BIGINT[3]/BIGINT[4], STRUCT(a)/STRUCT(b),
  DECIMAL/BIGINT) register and each call reaches its own overload.
  1.5.6: 4/4 pass. With 734bb15's signature.rs and collision.rs, 3 fail:
  every set and round(DECIMAL(18,3)) registers and the call then fails
  "Binder Error: Could not choose a best candidate function ..."; a probe of
  all eight scalar pairs at 734bb15 showed each one ambiguous on 1.5.6.
… slot (APIGAPS-4, CI-14)

What was wrong: a slot counted as "wrapped" when its name appeared in the
code of any file under src/, after stripping comments only. So
duckdb_open and duckdb_close, used only by #[cfg(test)] code
(src/query/live_tests.rs, client_context.rs tests), were in the 447, and a
name kept in a string literal satisfied the check after its wrapper was
deleted (ci reviewer probe cov-4 stayed green). AUDIT 5.1's own method gave
445 (apigaps reviewer, VALIDATED with an independent scanner).

Change:
- a small lexer strips comments (nested block comments too) and every
  literal (strings, raw/byte/C strings, chars; lifetimes stay code);
- items under a cfg that requires `test` (`test`, `all(.., test, ..)`;
  not `any(test, x)` or `not(test)`) are cut by brace/semicolon extent,
  and files loaded only through such a `mod x;` (with `#[path]`), plus
  their child modules, are skipped; src/bin/ is not library code;
- a new allowlist class `internal`: library code calls the slot but no
  public API exposes it (the apigaps reviewer found two: duckdb_create_bit,
  duckdb_result_error_type). Such a slot is not counted as wrapped, and is
  flagged if it stops being used. The allowlist file itself is agent `api`'s
  and is not edited here;
- the summary reports wrapped, internal-only and unused counts, and the
  names only tests/strings/comments mention; `--self-test` (23
  expectations on fixed snippets) runs in the abi-table job.

Effect on this branch alone: 546 slots (v1.5.6 header), 445 used by
library code, and the check fails with duckdb_open and duckdb_close
unclassified until the allowlist lists them (host-side: opening a database
is a host's job). That entry, and any `internal` ones, are agent `api`'s.

Ran: on both engine headers, the used set equals the apigaps reviewer's
derive.py (lib + testing) name by name: 445 and 445, no difference.
Probes on copies (FIX = open/close listed host-side), $S/impl/infra/mut_cov.py:
baseline green; RED for an allowlist line deleted, a wrapped slot listed,
the only wrapper removed, the name kept in a string (cov-4), in a raw
string, in a doc comment, the only call moved under #[cfg(test)] and under
cfg(all(feature, test)), an unused slot listed internal; GREEN for a used
slot listed internal (wrapped 445 -> 444) and a call under
cfg(any(test, feature)); the same on the v2.0.0 header. Scanner mutants
(raw strings kept, line comments kept, all() / any() predicate logic
broken, test-module files not skipped, src/bin counted): each fails the
self-test. ruff clean.
…T2-2)

What was wrong: map1/map2/try_map1/... return a TypedScalarFunctionBuilder,
which a ScalarFunctionSetBuilder could not take, so a closure-built function
could not be overloaded on DuckDB 1.4.x (a supported engine), where a second
registration under a taken name is refused - with a message telling the
user to use ScalarFunctionSetBuilder, which could not take it (reviewer
`author-types`, VALIDATED on 1.4.4).

Decision: the smallest clean path is an entry on the set builder, not a
conversion into ScalarOverloadBuilder: a ScalarOverloadBuilder is mutable
(`returns`, `param`, `function`, `extra_info`), which would reopen the
signature desync TypedScalarFunctionBuilder exists to prevent.

What changed:
- `ScalarFunctionSetBuilder::overload_typed(TypedScalarFunctionBuilder)`
  moves the closure's fixed signature, trampoline, extra_info, null handling
  and stability into one overload spec; nothing can edit them. The overload
  takes the set's name; one built under another name (case-insensitive) is
  refused by `register`/`check_parts` naming the overload, instead of
  registering under a name its builder did not say.
- The pre-1.5.0 "cannot add an overload" message names `overload_typed`
  next to `overload`; typed.rs module docs point at it.

Tests:
- unit: a_closure_built_overload_keeps_its_signature_and_takes_the_sets_name;
  an_engine_that_cannot_overload_refuses_every_existing_name now also
  checks the message names `overload_typed`.
- live: overload_keys::closure_built_functions_overload_one_name_through_a_set
  (i32/i64/f64 closures under one name; each call returns its own type; the
  one-by-one path is an overload from v1.5.0 and refused with the new
  message before it). 1.5.6: passes. At 734bb15 it cannot compile: there is
  no overload_typed, which is the defect.
…I-14)

What was wrong (ci reviewer's mutation run, CI-14):
- check-msrv-vs-duckdb-ci.py read only the first word of a SHA pin's
  comment, so `# v1.86.0` and `# rust 1.86.0` parsed as "v1.86.0" /
  "rust", i.e. floating, not a constraint; it also never read a
  `toolchain:` input, which is the only place a pin of the action's
  `master` branch (the style quack-rs's own workflows use) names its Rust.
  An upstream switch to any of those styles would have silenced the guard.
- check-autoload-entries.py had no floor: if upstream's entry shape
  changed, the pattern matched nothing and the union of nothing printed
  "OK: src/catalog.rs covers ..." with exit 0.

Change: the MSRV guard takes the first version number anywhere in the
comment (`v` stripped; `master 2026-10-08` still reads as floating), also
reads `toolchain:` inputs, and its self-test covers each style plus
parse(); exit codes unchanged. The autoload guard refuses (exit 2, "could
not parse", which fails a release run) when an array's parsed entries
differ from the number of `{` entries in it, or it has none; it retries a
fetch up to three times, since it makes two per release and a release run
now fails on exit 2.

Ran: real runs against upstream: msrv-vs-duckdb-ci OK (v2.0-cyanoptera
1.97.1; v1.5-variegata and v1.4-andium 1.86.0 + stable; main) and FAIL with
exit 1 on a copy with rust-version 1.88.0; autoload OK for 8 releases
v1.5.0..v2.0.0 (EXTENSION_TYPES 2, EXTENSION_COLLATIONS 130 at v2.0.0).
Parser mutants of the MSRV guard (first-word-only comments, toolchain:
inputs ignored, `v` not stripped): each fails its self-test. autoload's
upstream_names() on doctored copies of the real v2.0.0 header: a third
field in every entry, one reshaped entry, an emptied EXTENSION_TYPES ->
ValueError each; the previous code parsed 0, 129 and 0 names without
complaint. ruff clean. Not changed: check-platform-table's accept-list
(by design) and check-hello-ext's two checks that cannot fail (the
fixture is examples/hello-ext/sql_checks.txt, not mine; the script
already says so).
…pe, DECIMAL, alias types, ErrorData, COPY, table functions, Arrow, SET threads) and warn that std::fs bypasses DuckDB's permission settings

Each fix was re-run on DuckDB 1.4.4 / 1.5.6 / 2.0.0 (probe extensions built
from this tree; counts below are from those runs):
- scalar.md: the bind callback cannot set the return type (v1 C API has only
  bind_get_argument/_count/_extra_info/_set_error; grepped from the 2.0.0
  header). The raw examples are now scalar_callback! with checked arithmetic
  and report overflow through set_error (double_it(9223372036854775807) is a
  tested error); the closure example no longer teaches `x * 2`.
- scalar.md: a DECIMAL parameter is not generic. A DECIMAL(4,1) function that
  doubles 0.123::DECIMAL(3,3) returned 0.2 (argument rounded to 0.1) on 1.5.6
  and 2.0.0; a set with DECIMAL(4,1) and DECIMAL(9,3) overloads registers and
  every call fails "Could not choose a best candidate function".
- types.md: an alias type is not a CREATE TYPE synonym: sum/abs/+ do not bind
  ("No function matches ... 'sum(pr_money)'"), =, < and max do; asserted in a
  doctest against the live engine, and measured on 2.0.0.
- error-data.md: no callback API accepts an ErrorData.
- table-functions.md: bind runs again on every EXECUTE on 2.0.0 (1 bind / 3
  inits on 1.4.4 and 1.5.6, 4 binds / 3 inits on 2.0.0 for PREPARE + 3
  EXECUTE); the typed builder scans on one thread at SET threads = 8 (measured
  on 1.5.6 and 2.0.0); the zero-column bind is an INTERNAL Error with a C++
  stack trace without duckdb-1-5 on all three engines; the example no longer
  hard-codes 2048.
- copy-functions.md: unknown/valueless/list COPY TO options are accepted
  silently (a built-in format rejects them), no column names in bind, format
  chosen from the file extension when it equals the format name.
- arrow.md: a record batch with a root offset is refused.
- running-sql.md: SET threads from a callback aborted 2.0.0 in 3 of 4 runs and
  failed 5 of 6 on 1.5.6.
- AUTHT-1 (security): `std::fs` ignores `SET enable_external_access = false`
  and `allowed_directories`: read_csv and quack-rs's FileSystem get a
  Permission Error, a std::fs table function returns the file (1.5.6, 2.0.0).
  Stated in file-system.md (canonical section), table-functions.md,
  replacement-scan.md, copy-functions.md and the FAQ.

Ran: book doctest, 254 passed / 0 failed / 5 ignored (live 1.5.6).
…itations regrouped

- LESSONS.md L3 said "Made impossible" and omitted that a raw callback is not
  guarded (DOCS-2); brought in line with the book. The six titles that differed
  from the book's (P2, P3, P5, P7, P9, P12) now match it, so the book's
  published anchors stay; scripts/check-pitfalls-parity.py (a patch for infra)
  passes on the 38 pitfalls.
- L11 lists the crashing shapes as measured on 1.4.4, 1.5.6 and 2.0.0 (one
  process per shape, 5,000 and 300,000 rows): OVER (), explicit
  UNBOUNDED..UNBOUNDED ROWS/RANGE frames and agg(x ORDER BY y) segfault on
  1.4.4 and 1.5.6; OVER (PARTITION BY p) without ORDER BY segfaults on 1.4.4
  only; everything passes on 2.0.0.
- New pitfalls with the P11-P15 structure: L20 duckdb_register_log_storage
  frees its extra data twice when the name is taken (re-run with the apigaps
  probe on 1.5.6 and 2.0.0: the destructor ran twice on one pointer; source
  read at v2.0.0 and main), P16 duckdb_get_bit/duckdb_get_bignum abort on NULL
  and non-castable values (SIGABRT on 1.5.6 and 2.0.0), P17 std::fs bypasses
  the sandbox settings, L21 a claimed-but-unwritten ChunkWriter row is
  published with stale contents (rule only, no API name). Pitfall count 34 ->
  38 everywhere (README, intro, FAQ, contributing, ffi-reference).
- known-limitations.md regrouped (what your extension must get right /
  DuckDB defects / what the C API does not offer / 2.0 changes / resolved), so
  resolved history no longer sits between current limits (DOCS-12); headings
  keep their anchors. Added: std::fs, table-in-out/progress/filter pushdown/
  logging/secrets absent from v1, a quack-rs extension cannot be linked
  statically into a 2.0 host (read at v2.0.0), the five 2.0 changes missing from
  AUDIT 12.4, panics that cannot be caught. The C API v2 list named
  duckdb_v2_table_function_set_filter_pushdown, which does not exist (it is
  ..._callback); every name now cited was grepped in duckdb_v2.h.
- docs/ffi-reference.md: its 12 uncompiled `rust` fences are `rust,ignore`/`text`
  with a note that they are sketches (patch 05 hunks).
…s, function descriptions, ref keys, footer version, drifted statements); note on archived reports

(The two historical reports docs/E2E_DOGFOOD_REPORT.md and
docs/duckdb-v1.5.1-evaluation.md were moved to docs/archive/ in the previous
commit: they already carried historical banners and nothing linked them; their
relative links are fixed.)

Every claim re-checked against the upstream file at the stated ref before it
was written (raw.githubusercontent.com / duckdb.org, 2026-10-30):
- Reserved names (CONFORM-3): extension_alias.cpp at v2.0.0 (10 aliases) and
  the 31 names of the 2.0 core-extensions table; `INSTALL s3 FROM community`
  on 2.0.0 fails "Failed to download extension httpfs ... (HTTP 404)", md and
  sqlite3 likewise (re-run).
- function_descriptions.csv (CONFORM-7): scripts/generate_md.sh in
  community-extensions reads extensions/<name>/docs/function_descriptions.csv
  from that repository and left-joins it on function name, replacing
  description/comment/example; header seen in extensions/h3.
- Revision keys (CONFORM-8): scripts/build.py selects andium for v1.4.5,
  variegata for v1.5.6, ref_next for other non-latest versions, else ref;
  DUCKDB_LATEST_STABLE is v2.0.0 in build.yml; it reads exactly the keys
  listed, everything else is ignored.
- Footer version (CONFORM-9): configure_helper.py uses `git tag --points-at
  HEAD` else `git log -1 --format=%h`, not `git describe`; reproduced: no
  commit -> "error: malformed object name 'HEAD'", two tags -> two lines.
- Drift (CONFORM-11): v1.5.6 and v1.5-variegata are different commits
  (ls-remote); the description.yml example is now the real scaffold output
  (license quoted, variegata comment); the Cargo.toml snippet gets
  rust-version/resolver; the matrix script differs per branch (Python
  modify_distribution_matrix.py on v1.5-variegata and v1.4-andium, Go extbuild
  on v2.0-cyanoptera).
- CONFORM-14: reduced-CI flags from distribution_matrix.json (linux_amd64,
  windows_amd64, wasm_eh); `strip` on a stamped file exits 0 and LOAD then
  fails "The metadata at the end of the file is invalid" (run);
  requires_toolchains is matched as ;token;.
…SE follows them (DOCS-13, HARDEN-10)

What was wrong: the table listed 0.1.x and 0.2.x, which were never
published, gave every 0.x line its own row, and said nothing about what
the old releases carry; it named 0.19.x and 0.18.x as supported, which is
not what the release this branch feeds (0.20.0) should say. Nothing tied
the versioned book's MIN_RELEASE to the table (RELEASING.md Step 2b asked
for it by hand).

Change (the harden reviewer's patch 08 and the docs reviewer's patch 06,
merged by hand; they conflicted):
- supported: 0.20.x and 0.19.x; end-of-life: 0.18.x, 0.16.x, and
  0.3.x - 0.15.x marked "do not use". Policy stated: the two newest minor
  lines, because Cargo treats a 0.x minor as a new major line, so
  `quack-rs = "0.19"` users never reach 0.20 by themselves and need the
  previous line fixed for one more cycle; 0.18.x ends with 0.20.0. This
  matches what the table already did (two lines) without inventing a
  date.
- what releases before 0.16.0 carry, with version ranges checked in the
  published .crate files, not copied from either patch: from_bytes
  0.3.0-0.15.0; get_file_path's free 0.8.0-0.15.0 (absent in 0.6.0/0.7.0:
  docs patch 06 said "0.7.0 through 0.15.0"); no ABI layout check with the
  duckdb-1-5 feature 0.4.0-0.15.0 (the feature exists from 0.4.0; harden
  said 0.8.0). None yanked. No 0.1.x/0.2.x on crates.io; no 0.17.x.
- scripts/build-versioned-site.py MIN_RELEASE (0, 18, 0) -> (0, 19, 0), as
  RELEASING Step 2b requires in the commit that ends a line; the site drops
  /v0.18/ on the next docs.yml deploy.
- scripts/check-release-metadata.py now fails while MIN_RELEASE differs
  from the oldest `| X.Y.x | Yes` line in SECURITY.md.

Ran: crates.io API: 18 versions, oldest 0.3.0, newest 0.19.0, none
yanked; the .crate files of 0.3.0, 0.4.0, 0.5.0, 0.6.0, 0.7.0, 0.8.0,
0.15.0, 0.16.0 extracted and grepped (features table; get_file_path's
body; from_bytes's signature). check-release-metadata on this tree:
agrees; copies with MIN_RELEASE left at 0.18, with 0.18.x marked
supported again, and with 0.19.x dropped while Cargo.toml says 0.19.0:
each exit 1 with the matching error. typos and ruff clean. Not run: the
versioned-site build (this clone has no release tags).
…I-6, FFI-12)

FFI-6, what was wrong: ScalarBindData's copy callback returned null when
T::clone panicked, and DuckDB's CScalarFunctionBindData::Copy then gave the
copied expression no bind data: the query answered as if none had been set
((NULL, 0) instead of (4752, 32) in reviewer `ffi`'s filter-pushdown probe,
VALIDATED on 1.5.6 and 2.0.0) and the panic message was lost.

What changed: the allocation is a private Slot<T> (Value or CopyFailed with
the panic message); all four of set/get/drop/copy are quack-rs-generated.
A failed copy now yields a CopyFailed slot, never null. `get` reports it as
the call's error through ScalarFunctionInfo::set_error (so the query fails
with "... the bind data's Clone panicked ...: <message>") and returns None;
`get_from_init` does the same through ScalarInitInfo::set_error; the new
`try_get` returns the message as Err for a callback that wants to handle it
(a later set_error in the callback would replace get's report; documented).

FFI-12, what was wrong (documented, reviewer validated): a second
ScalarBindData::set in one bind leaked the first value, because
duckdb_scalar_function_set_bind_data is a plain assignment (read at v1.5.6
and v2.0.0) and the C API cannot read the pointer back. Fixed, as it was
small: ScalarBindInfo remembers what ScalarBindData::set stored through it
(a Cell), and a second set frees the replaced value after overwriting
DuckDB's pointer. The raw set_bind_data clears the record (its pointers are
the caller's, who may hand the same one back), so a value replaced through
it, or through another wrapper of the same bind call, still leaks;
documented on both.

Tests:
- unit: a_panicking_clone_is_reported_when_the_copy_is_read (replaces
  a_panicking_clone_yields_null_instead_of_unwinding, which pinned the bug),
  plus the copy/null tests moved to Slot.
- live (scalar_bind_data_copy.rs):
  a_panicking_bind_data_clone_fails_the_query_with_its_message (get and
  try_get) - 1.5.6 passes; with 734bb15's src/scalar/state.rs (try_get
  swapped for get so it compiles) it fails "bomb_get: answered (None, 0)
  instead of failing";
  setting_typed_bind_data_twice_drops_the_first_value - 1.5.6 passes; with
  the free removed (734bb15's behaviour) "left: 7 right: 9" (two leaked, one
  per bind).
…low, secrets, summaries (DOCS-1, CI-1, CI-5, CI-15, HARDEN-9)

What was wrong (ci, docs and harden reviewers; their patches 03, 08 and
08 conflicted on this file and are merged by hand):
- Step 3 said "Do not update Cargo.lock manually" and Step 4 staged only
  CHANGELOG.md and Cargo.toml, while release.yml packages and publishes
  with --locked: following the runbook failed the release after all of CI
  (DOCS-1 High, CI-1). Four other lockfiles record quack-rs's version too.
- The hotfix procedure tagged the hotfix branch and cherry-picked onto
  main afterwards; `validate` refuses a tag not on main, and a cherry-pick
  is a different commit (CI-5, simulated by the ci reviewer).
- The fallback crates.io token was documented as a repository secret,
  readable by any workflow, so the crates-io environment's reviewer could
  be bypassed; no Trusted Publishing set-up order (HARDEN-9).
- Appendix F mismatches: "each job writes a summary" (two do); "read the
  package job's summary" (it writes none); tags "annotated and signed"
  (only annotation is checked); Step 9's versions.json check is wrong for a
  pre-release; troubleshooting named deny.toml only; the crates.io hash
  check described as after-upload only.

Change: TL;DR and Step 3 run `cargo update --workspace` in the root,
examples/hello-ext, fuzz, book/doctest and benches/engine and commit the
lockfiles in the same commit, saying why (--locked); Step 3b lists
SECURITY.md, the README "latest" line, the two dates the grep cannot find
(docs patch 08's note), and scripts/check-release-metadata.py; Step 4
stages every lockfile; Step 2b states the two-lines policy and that the
script ties SECURITY.md to MIN_RELEASE; Step 5 says validate checks
annotation, not the signature; Steps 6-7 describe the pre-upload hash
check and the recorded rustc; the hotfix section merges the branch into
main with a merge commit and tags the hotfix tip (ci patch 03's text, plus
what to keep on main when the merge conflicts); Prerequisites take harden
patch 08's environment-secret rows and set-up order (with its report's
stop-gap step: move an existing repository secret into the environment);
Step 1 names the four informational jobs, which may be red; troubleshooting
covers a release-metadata failure, the CI-crates deny config and
osv-scanner.toml, the pre-upload stop, and the environment secret.

Ran: typos clean; shellcheck 0.11.0 on the 12 bash blocks: only the
pre-existing `<run-id>` placeholder in Step 1 fails to parse. The commands
were run elsewhere in this branch's verification: `cargo update
--workspace --offline` in each lockfile directory changes exactly one line
(the quack-rs version); check-release-metadata as described. The hotfix
flow was simulated by the ci reviewer (scenario E2), not by me; the
GitHub environment settings cannot be read from here.
claude added 29 commits October 30, 2026 08:03
…igned part, 35 new tests, 4 fuzz targets

TESTS-1 (High). lsan-suppressions.txt held `leak:libduckdb.so`. LeakSanitizer
tests a suppression against every frame of an allocation stack and every handle
DuckDB allocates has a libduckdb.so frame, so the leak-check job could not report
a missing duckdb_destroy_*. Measured here with tests/lsan_probe.rs (nightly,
-Zsanitizer=leak, prebuilt libduckdb 1.5.6): with the old file a leaked
LogicalType and a leaked Value exit 0; with the rule removed both exit 23 with a
leak report; the Rust-allocation control exits 23 under both. The suppression was
not needed: the whole ffi_roundtrip suite (460 tests) exits 0 under LeakSanitizer
with no rule. The file now holds a comment only, and the leak-check job has a step
that leaks a Rust allocation, a LogicalType and a Value on purpose and requires a
LeakSanitizer report each time (and a pass when nothing leaks).

TESTS-9 (Low). abi::parse_version took a leading `+` in a part (`u64::from_str`).
Digits only now; build.rs already had the same rule (HARDEN-12), its comment says
so. property_inputs::parse_version_refuses_a_part_that_is_not_plain_decimal fails
on ef97dd5 (minimal input `0.+0.0`, saved in the proptest-regressions file) and
passes now.

TESTS-3..7 (Medium). Tests that kill mutants the suite let live, found by
exposing the bodies of `unsafe fn`s that cargo-mutants skips: wide_rows (u128 and
every other fixed-width stride over 5,000 rows), vector_capacity_guard (MAP and
UNION arms), 12 Arrow layout-walker unit tests, abi_policy_enforced (the
`AbiPolicy` dispatch in-process against a v1.4.4 layout table), lifecycle_gaps
(get_from_init, the two extra_info destructors, abi::check), connection_registrar
(seven Registrar methods of Connection nothing executed), oracle_temporal (4,000
random values per check against DuckDB's own SQL). The reviewer's import_layout
test a_list_far_into_its_child_converts_the_distance_between_its_offsets is
dropped, not adapted: with the FFI-1 bounds check that layout (a list starting
at element 2^40 of a 3-element child) is refused before the arithmetic it
targeted, and list_offsets_outside_the_child_are_refused covers the refusal.
Its dictionary shapes use dictionary_of() because Shape now carries `indices`.

TESTS-13 (Low). Fuzz targets abi_version, append_metadata, description_roundtrip
and scaffold_text, each with a seed directory (the fuzz job copies
fuzz/seeds/<target>/ and would have failed without one). Each ran 60 s on the
merged tree; description_roundtrip found a crash in its own escaping (PyYAML
refuses U+007F even inside quotes, so the target must escape it) and ran 787,689
inputs clean after the fix.

Not adopted: the reviewer's TESTS-8 patch (strip a leading `_` from every
symbol). The tree already tells a Mach-O symbol table from an ELF one by its
magic; the reviewer's repro input now produces no warning, and an ELF symbol
`_my_ext_init_c_api` really is a different symbol DuckDB cannot load, which the
blanket strip would have silenced.

Ran: cargo fmt --check; clippy --all-targets -D warnings with default,
duckdb-1-5-4 and bundled-test-prebuilt,duckdb-1-5-4; the new live modules on
engine 1.5.6 (11 passed); property_inputs (10), abi_policy_enforced (1),
import_layout (38, duckdb-1-5-4); documented_source_trees_match_the_filesystem.
Not run: the new live tests on 2.0.0, 1.4.4 and 1.5.0-1.5.5.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
On 2.0.0, CAST(make_timestamp(m) AS VARCHAR) for m below -9223372022400000000
(except the -i64::MAX sentinel) raises an INTERNAL error (the `__cast` function
"threw an execution error, but the function is not marked as fallible"), which
TRY() does not catch; 1.x answers NULL. The first run of the reviewer's
timestamp oracle on 2.0.0 (the reviewer had no 2.0 build) failed on it. On 2.0.0
those values are no longer put to the engine and are expected to be refused by
the wrapper; the 1.x runs hold the engine to that answer.

Ran oracle_temporal on 1.5.6 (4 passed) and on 2.0.0 with the 1.20000.1
bindings (4 passed). The rest of the live suite on 2.0.0 had passed except this
one test (459 of 460 in ffi_roundtrip before this change).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…an unreachable upstream on the weekly schedule

TESTS-10. The five scripts that compare a checked-in table with upstream
returned 2 ("could not check", a warning and a green job on a pull request) for
an HTTP 404 and for "the layout may have changed" as well as for an unreachable
network. Reproduced on the previous tree:
check-platform-table.py --ref this-ref-does-not-exist exited 2 with a warning.
If upstream renamed config/distribution_matrix.json, moved extension_entries.hpp
or reshaped licenses.json, the gate would have degraded silently and for good.

Now 2 means a network failure, a 5xx or a 429; an HTTP 4xx (other than 429), an
entry without duckdb_arch, an empty list, a registry without the expected key,
a header the autoload parser cannot read, a workflow without a toolchain pin and
every release answering 404 are 1. upstream-guard.sh also fails a 2 when
GITHUB_EVENT_NAME is schedule (it already did on a release tag), so a gate that
has not run for a week is noticed; its self-test has five more cases (14 in all, counted from the run).

Ran: upstream-guard.sh --self-test (14 cases ok); against live upstream,
platform (--ref this-ref-does-not-exist: exit 1, current ref: 0), spdx 0,
autoload --tags v1.5.5 0 and --tags v9.9.9 1, msrv 0, abi-table full 0 and
--tags v9.9.9 1. The old exit code (2) is measured only for the platform case
(the reviewer's repro); for autoload and abi-table it is read from the code
(HTTPError is a URLError; `if not rows: return 2`).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…x test job instead of skipping

TESTS-14. adversarial_text_round_trips_through_pyyaml, workflows_parse_as_yaml
and the make-driven tests print "skipping" and return when the tool is absent;
cargo test hides stderr, so a runner without PyYAML kept them green while
checking nothing. QUACK_REQUIRE_TOOLS=1 turns the skip into a failure; ci.yml
sets it on the Linux leg of the test job, after installing python3-yaml, make
and git. macOS and Windows keep the skip (not verified whether those images
have PyYAML).

Shown with a stand-in python3 that reports "No module named 'yaml'": both tests
pass with the variable unset and fail with QUACK_REQUIRE_TOOLS=1 (message names
the tool); with the real python3 and PyYAML 6.0.3 they pass either way. The
decision is a pure function with its own unit test. cargo test --lib scaffold:
108 passed (was 107). Not run: the Linux job itself (apt install step).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…it, fix two comments

TESTS-2 (High, documentation and tooling). cargo-mutants 27.1.0 generates no
mutants inside unsafe fn bodies and never mutates integer literals, and nothing
in the repository said so; the AUDIT's "0 missed" results never covered the
pointer arithmetic. Measured on this tree with cargo-mutants 27.1.0 and
--features duckdb-1-5-4: 2,488 mutants with .cargo/mutants.toml, 3,748 with
--no-config; by the reviewer's heuristic script 506 unsafe fns hold 5,127 of
22,898 non-test lines (22.4%). On src/vector/reader.rs and writer.rs, mutants
listed: 6 as is, 192 with the unsafe keyword removed from signatures, 344 with
the literals wrapped as well, and the rewritten copy passes cargo check.

CONTRIBUTING.md's mutation section now states the blind spot and where the live
suite and the sanitizers stand in for it. scripts/mutants-expose-unsafe.py is
the reviewer's mutprep.py and rsutil.py as one script (its output on
vector/reader.rs is byte-identical to the original's); it is an audit aid for a
copy of the tree and is not run in CI. The reviewer's other proposal, a CI job
that runs it with the live suite, is not adopted: hours of runtime, and a text
rewriter in the loop.

TESTS-12/15. tests/ffi_roundtrip.rs said the Arrow module is run by the miri
job (Miri cannot call foreign code; leak-check and asan run it); validity.rs
pointed at tests/integration_test.rs for tests that live in
tests/ffi_roundtrip/validity_api.rs and nested_validity.rs.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
TESTS-11. src/callback.rs was excluded wholesale as "macro-generated FFI
wrappers", but catch_ffi_panic, panic_message, panic_c_message and
message_to_c_string are plain functions (cargo-mutants cannot see inside the
macros anyway). With the exclusion removed: cargo mutants --no-config --features
duckdb-1-5-4 --file src/callback.rs --cargo-arg=--lib lists 5 mutants; 4 caught,
1 unviable, 0 missed (57 s). The configured list is 2,493 mutants (was 2,488).

Not changed, for the owner: the full mutation sweep is workflow_dispatch only
(no schedule), and the pull-request job runs --lib, so files whose mutants only
a live engine can kill (those under exclude_globs) are not mutated in CI. The
reviewer counted 42 such files on an older tree; not recounted here.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
The ceiling (<1.20100, below the DuckDB 2.1 bindings) is written in six places:
the root manifest, examples/hello-ext, fuzz, benches/engine, book/doctest and the
manifest the scaffold generates. every_manifest_states_the_same_bindings_requirement
compares the five others with the root's. Negative control: changing fuzz/Cargo.toml
to '>=1.4.4, <2' fails it, naming the file; restored, it passes.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
SqlMacro::register (32e8d64) reads the parser's message through it, so the
allowlist's 'host-side' line was stale and scripts/check-api-coverage.py exited 1.
Now: 546 slots at v1.5.6, 457 wrapped, 89 not used (8 candidate, 45 deprecated,
23 host-side, 13 superseded); exit 0.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
Cargo.toml and CITATION.cff say 0.20.0 (2026-10-30), README's latest line and the
four remaining 0.19 snippets follow, and the CHANGELOG's [Unreleased] section is
now [0.20.0] with the six work packages' entries, the tests-review entries and a
Security entry for SqlMacro (SQLMACRO-1). Breaking items are marked inline. The
book's changelog is synced; scripts/check-release-metadata.py passes (all five
lockfiles, CHANGELOG heading and links, CITATION, README, SECURITY, snippets).

Lockfiles: every one records quack-rs 0.20.0. Root: proptest 1.12.0 and cc 1.10.0
only (Dependabot #148); libduckdb-sys and duckdb stay at 1.10506.1. fuzz and
book/doctest: cc 1.10.0 (#149). examples/hello-ext: libduckdb-sys 1.20000.1 (#143
asked for 1.20000.0, whose bundled engine reports v2.0.0-dev88614); it builds, and
its 32 live checks pass on DuckDB 1.4.4, 1.5.6 and 2.0.0 (32/32 each), 43 unit
tests pass. benches/engine/Cargo.lock is committed (.gitignore line removed, CI's
deny and OSV steps and the release-metadata check no longer treat it as optional).

hello-ext has 32 checks now (T30 added with the scaffold work); CONTRIBUTING,
ci.yml and check-hello-ext.py said 31. The Performance table is re-measured with
benches/engine/compare.py against a v0.19.0 export on this tree (1.5.6: 6 sessions
x 3 runs; 2.0.0: 4 x 3); the ListBuilder NULL-element row is 10.72 ns, not the 8.60
the earlier table gave. Docs-link fixes: the oldest tag and crates.io release are
0.3.0 (checked with git tag and the crates.io API), so the dead 0.1.0/0.2.0 compare
links are gone; the C-DEBUG link is the debuggability page (HTTP 200).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
The book, the rustdoc and a few code comments named the review that made an
observation ("the author-tables review", "the conform review", reviewer `ffi`).
That is process, not information for a reader; the evidence labels stay (built and
loaded, read in the source and not run, observed in a review and not re-run).
Also checked against freshly generated projects: the scaffold chapter's file
tree (15 files), the v1.5.6 bindings pin (~1.10506.0 plus the duckdb-1-5-4
feature), the refusal of an unstable 2.x target, the dual-license file names and
the LICENSE.TODO fallback all match.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
… own differential numbers

typos 1.46 flagged 'dictionarys' (a test name in the Arrow layout tests, renamed)
and two deliberate 'SELEC' statements in tests/ffi_roundtrip/query_metadata.rs
(allowed by pattern in typos.toml). typos now exits 0; actionlint with CI's
-ignore SC2129 exits 0.

The CHANGELOG's description.yml claim is now what I measured, not the work
package's figure: a scratch crate calls parse_description_yml on the 395
descriptors of community-extensions 845779e and on 3 x 39,500 random mutants
(deleted/inserted/replaced characters from a YAML-significant alphabet, line
duplication, deletion, swaps, re-indentation, truncation) and compares with
PyYAML 6.0.3 yaml.safe_load: originals 395/395 agree; mutants: 0 accepted that
PyYAML refuses and 0 panics. The other direction was not classified:
quack-rs accepts 18,398 / 18,080 / 18,426 of the mutants and PyYAML loads
24,846 / 24,501 / 24,820, and what separates them (description.yml validation
rules, the work package's eight deliberate strictnesses) was not itemised here.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
cargo-semver-checks 0.51.0 against v0.19.0 (--release-type patch, features
duckdb-1-5-4,_duckdb-testing) reports two breaking changes: the four enums that are
#[non_exhaustive] (already listed) and ScalarBindInfo losing RefUnwindSafe, which
FFI-12's Cell<Option<..>> field causes and nobody had listed.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…the live configuration sees

Section 14 records the method (twelve reviewers, six work packages), the High
findings with the evidence for each, the other findings by package with what is
VALIDATED here and what is REPORTED, what was declined or rejected and why, the
owner-only actions, what was not verified, the re-measured performance with
spreads, the verification record for the final tree, corrections to earlier
sections, and the process lessons. The header of the file and 13.7 point to it.

tests/ffi_roundtrip.rs: LeakSanitizer in a doc comment needed backticks
(clippy::doc_markdown), which fails clippy --all-targets only in the live
configurations (bundled-test-prebuilt) because only they compile that file; found
by running clippy there on the final tree. All four live configurations pass now.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
cargo test --doc --locked --manifest-path book/doctest/Cargo.toml against libduckdb 1.5.6
with the lock's 1.10506.1 bindings, RUSTFLAGS and RUSTDOCFLAGS -D warnings.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…, scaffold-e2e dependency line, wasm stack

Run 711 (03cc120) failed in places the local gates cannot reach:

- Windows: src/scaffold/tests_make.rs is Unix-only, but its helper functions were
  compiled and unused there, so -D dead-code failed the lib test build. The module
  is now declared #[cfg(all(test, unix))].
- macOS: a_file_name_that_is_not_utf8_is_used_not_a_panic cannot create its input
  (APFS/HFS+ refuse a non-UTF-8 name: EILSEQ, 'Illegal byte sequence'); it is gated
  to Unix without macOS. Names that are only arguments (no file) are still tested.
- scaffold-e2e, 'C API v1.5.6' step: its regex wanted '{ version = ".." }' but
  the scaffold now writes '{ version = "0.20", features = ["duckdb-1-5-4"] }' for a
  v1.5.6 project; the step rewrites only the version into a path and asserts the
  feature is there.
- wasm: the description.yml depth test recursed 64 levels in a debug build and ran
  out of emscripten's 64 KB default stack ('memory access out of bounds' in
  block::parse_seq); the unit-test step links with -sSTACK_SIZE=8MB.

Verified here: actionlint (CI's flags), the scaffold unit tests and
append_metadata_cli on Linux, clippy -D warnings. NOT verified: any of the four on
the platform it is about; the next CI run is the check. Also seen in run 711 and
not reproduced: a stack overflow in ffi_roundtrip against DuckDB 1.4.5 (the
suite passes 3 of 3 here against the same 1.4.5 library and bindings, with CI's
RUST_BACKTRACE=1).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…et/ for the 2.0 source build

The informational Nightly job failed tests/build_script_env.rs: nightly Cargo
(1.101.0-nightly, 2026-10-23) lays a package out as build/<package>/<hash>/out/
(build_script_build, and the test binary itself in out/), not
build/<package>-<hash>/build-script-build. The old finder panicked 'Cargo compiled
quack-rs's build script for this test run' there (reproduced), and passes on
stable; the new one finds the script in both layouts (nightly and 1.99.1 both run
green here).

The informational 'bundled-test on the DuckDB 2.0 bindings' job stops in the build
script ('neither duckdb_extension.h nor duckdb.hpp is there') on a restored cache:
the 1.20000 bindings unpack DuckDB's sources into target/duckdb-sources/, which the
cache does not carry, while the build record it does carry says the sources are
there. The job now sets cache-targets: false so it builds from scratch. This is my
reading of runs 705 and 711 (CONJECTURED): the job needs a source build to confirm.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…indows dead code)

CI run 716 (6005f64), Test (windows-2025): temp_files in
src/bin/append_metadata/tests_output.rs is used only by Unix tests, so -D dead-code
failed the bin's test build; the Path import became unused with it. Both are
#[cfg(unix)] now.

This one was the second of its kind (tests_make.rs was the first), so the rest was
found locally: cargo check --all-targets with RUSTFLAGS='-D warnings' for
x86_64-pc-windows-gnu (cfg(windows)) and aarch64-apple-darwin, with and without
duckdb-1-5-4, using CC=true for the one C build script (criterion's alloca) that
a check does not need. Both finish clean, and so does Linux. That checks that
the code compiles there, not that the tests pass there.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…the nesting cap at its boundary instead

The macOS source-build leg and, once, the Linux 1.4.5 leg aborted in
`hostile_input::a_deeply_nested_type_is_refused_not_recursed_into` with a
stack overflow. Cause, from a gdb backtrace of the old test on a 512 KiB
stack (1.5.6, prebuilt): the test registered a scalar set whose overload
parameter was 3,500 levels deep, and the next `register_table` ran its name
check, a `duckdb_functions()` scan, in which DuckDB's own
`LogicalType::ToString` recursed once per level. How much stack that needs
depends on how DuckDB was built, so a 2 MiB thread was enough on a prebuilt
library and not on every other build. The test itself left the trap in the
catalog.

The replacement stops at the cap (256, `table::type_check::MAX_TYPE_NESTING`)
and asserts what the cap changes instead of whether the process survived:
a scalar return type nested 256 levels registers and 257 is refused; a set
whose two overloads differ only 300 levels down is refused as a duplicate
(rendering stops at the cap) while 255 levels down they register; and a
table function still registers after such a set.

Checked by changing `MAX_TYPE_NESTING` and running the test on 1.5.6: with
100000 and with 255 and with 257 the scalar boundary assertions fail
(the 257-deep type registers, or the 256-deep one is refused); with the
scalar block reduced to its passing case, 100000 fails the set assertion.
The new test passes with RUST_MIN_STACK down to 384 KiB and overflows at
256 KiB on 1.5.6; unrelated tests in the file pass at 128 KiB. The full
`ffi_roundtrip` binary passes on 1.5.6 (460 tests), 2.0.0 (460), 1.4.5 (308,
three runs) and 1.4.4 (308). The old test also passed on 1.4.5 locally, so
that run does not discriminate; the backtrace and the mutation runs do.
The macOS source build itself was not run here.

`MAX_TYPE_NESTING`'s documentation now says what the overflow involved and
that a type past the cap is refused with the ANY/INVALID message.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…ut of the limit

`cargo llvm-cov` (the Coverage workflow) failed on 928b1a8 with
"invalid instrumentation profile data (file header is corrupt)" and
"no profile can be merged", although every test passed. Reproduced
locally with `cargo llvm-cov llvm-cov --no-report` on the prebuilt
1.5.6 engine: of 91 profile files exactly one failed
`llvm-profdata show`, 4096 bytes long; its name carried the signature
that `append_metadata` writes (found by running the binary with
LLVM_PROFILE_FILE set), and the other 14 files with that signature are
42,888 bytes.

The file is the instrumented child of
`a_failed_write_leaves_nothing_behind_and_names_the_output`, which runs
`append_metadata` under `ulimit -f 8` (a 4 KiB file limit) to provoke
EFBIG: the profile the child writes on exit is cut off at the limit. The
child now writes its profile to /dev/null, which the limit does not
apply to.

After the change the same test binary under cargo-llvm-cov leaves 15
profile files, all accepted by `llvm-profdata show`, and the full
`cargo llvm-cov --all-targets --features bundled-test-prebuilt,duckdb-1-5-4
--lcov` run exits 0 with 1,789 tests passed, 0 failed, and an lcov file
covering 160 source files. The workflow itself uses `--all-features`
(the source-built engine), which was not run here.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
… does not race on the extension directory

On 2be944d the windows-2025 bundled-test job ran `ffi_roundtrip` to the end
(the stack overflow of 928b1a8 is gone there) and 457 of 458 passed. The
failure:

  the_name_validator_accepts_every_name_duckdb_does:
  SELECT DISTINCT extension_name FROM duckdb_extensions(): IO Error: Cannot
  open file ".../v1.5.6/windows_amd64/parquet.duckdb_extension.tmp-<uuid>
  .duckdb_extension.info": The process cannot access the file because it is
  being used by another process.

That is another thread's install of `parquet` in progress: a source-built
DuckDB has no parquet, and the only test that asks for it is
`table_cast::registering_a_taken_copy_function_name_is_an_error`, which
registers a COPY format named "parquet" (my reading; the Windows run is not
reproducible here). It is the race `install_icu_once` already removed for ICU
("Could not move file: Access is denied"). The helper is now
`install_extensions_once` and runs `INSTALL icu` and `INSTALL parquet` inside
the same `call_once`, so every other fixture waits for the installs and only
loads. A library that carries the extension treats INSTALL as a no-op, and a
failed install (no network) is ignored as before. The doc comment that
belonged to `Fixture` had ended up on the helper; it is back on the struct.

Checked here: the full `ffi_roundtrip` binary passes on 1.5.6 (460), 2.0.0
(460) and 1.4.5 (308), and clippy -D warnings is clean in the live
configuration. These are all prebuilt libraries, where the change is a no-op,
so they show nothing about the race itself; whether it is gone is the
windows-2025 job's answer. Of the 58 jobs of run 724 on 2be944d, 56
succeeded, this one failed and Miri was still running when I read them.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…aught

Nine problems that appeared only on GitHub's runners after the local gates
passed, none needing a change to the shipped library code: Windows dead code,
the macOS non-UTF-8 file name, the scaffold-e2e dependency line, the wasm
stack, the nightly build-script layout, the DuckDB 2.0 source-build cache, the
deep-type test (cause from a gdb backtrace, plus the limitation that a
parameter type past the 256-level cap still registers), the Coverage profile
truncated by `ulimit -f`, and the Windows extension-directory race. The Windows
race fix is recorded as unconfirmed: the windows-2025 job decides.

14.10 gains three lessons: assert outcomes rather than survival, coverage
changes what children do, and compare a check's head with the branch head
before reading its failure.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…nse_terms unable to hang

The Mutation Testing (incremental) job on 4036f7a reported twelve missed
mutants in changed code before its runner shut down at 33 minutes:
`parse_version::decimal` (`||` to `&&`), the "v1.5.6" and "v1.4.5" arms of
`warn_about_the_community_build_of_an_unstable_binary`, `license_files` (`||`
to `&&` in the split), five in `templates::quack_rs_feature` and two in
`templates_docs::license_terms`. Tests that kill them:

- `abi::tests::parse_version_refuses_a_plus_sign_in_any_part`
- `the_unstable_binary_warning_names_the_ref_the_release_is_submitted_as`
  (the other two messages also mention repo.variegata, so only the whole
  sentence tells them apart)
- `the_quack_rs_feature_follows_the_release_the_project_is_stamped_for`
- `a_parenthesised_license_is_split_into_its_identifiers`
- `a_license_with_an_exception_is_allowed_as_one_term`, and two assertions
  in the existing deny.toml test.

Running cargo-mutants 27.1.0 with the job's flags on those five files
(`--re` on the five functions, 59 mutants) found three more survivors in
`license_terms` (`i + 1` to `i - 1` and `i * 1`, `==` to `!=`), which the
job had not reached, and, after the first fix, three mutants that made the
`i += n` loop run forever (timeouts, which the gate counts as failures).
`license_terms` now walks the tokens with a peekable iterator, so every pass
takes a token and none of its mutants can hang. Results: before the rewrite,
59 mutants in the five functions gave 44 caught, 12 unviable and 3 timeouts,
no survivor; after it, `license_terms` alone (8 mutants) gave 5 caught and 3
unviable. The other four functions were not re-run after the rewrite, which
does not touch them.

The job generated 1,655 mutants for this pull request and had tested a
fraction of them when it stopped, so this is not the whole picture; a local
sweep of all changed files follows.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…were reachable

Run 41048719895 on 1249dc4: 57 of 59 jobs succeeded, `Miri (undefined
behaviour)` was cancelled and so `CI passed` failed. The job's two steps run in
sequence under a 60-minute limit: the native step took 41.6 minutes
(11:34:27 to 12:16:03) and the s390x step was cancelled 18 minutes in, when the
job's hour ran out. The gaps between consecutive "test ... ok" lines in that
step's log (tests run in parallel, so this attributes wall time, not CPU) put
1,086 s on `tests_pyyaml::deep_nesting_is_an_error_not_a_stack_overflow`
(100,000-level inputs through a parser with no `unsafe`) and 160 s on
`spdx::sibling_groups_do_not_count_towards_the_nesting_limit`. Under Miri
those two use 1,000 levels and 3 groups, as `spdx.rs` already did for its other
deep-nesting test; natively they are unchanged. Both versions pass here: full
size natively, and the Miri-sized one run natively with RUSTFLAGS="--cfg miri".
The job's limit goes to 90 minutes: by the same log the rest of the native step
is about 21 minutes, so the two steps should need about 45, but I have not run
Miri locally and the first run on this commit is the measurement.

The Mutation Testing (incremental) job on the same head tested part of the 1,639
mutants before its runner shut down at 55 minutes and reported six survivors:

- `scalar/builder/collision.rs` `overload_key`, `c == '_'` to `!=`: the test
  now has `x_DECIMAL(4,1)` and `x_MAP(a, b)`, which an underscore must keep.
- `scaffold/tests_make.rs` (`have`, three mutants): that module is declared
  `#[cfg(all(test, unix))]`, which cargo-mutants does not recognise as test-only
  and so mutated its helpers. It is `#[cfg(test)]` plus `#[cfg(unix)]` now.
- `LogicalType::refuse_where_the_engine_lacks` (two mutants) needs a live engine
  for `abi::engine_version`. Applied by hand against libduckdb 1.5.6,
  `timestamp_tz_ns::the_type_id_is_reported_for_a_column_and_creatable_only_where_it_exists`
  passes unmutated (5 of 5 tests) and fails with the body replaced by `Ok(())` and
  with `==` changed to `!=`. It is excluded from the --lib gate in
  `.cargo/mutants.toml` with that evidence, like its neighbour `try_new`.

Not claimed: the job cannot finish on this pull request (1,639 mutants at about
20 s each over 4 jobs is about 2 hours against a 60-minute limit, and its
runner stopped at 33 and 55 minutes in the two runs), so a green mutation check
here is not expected. A local sweep with the job's flags over all 102 changed
files is running; its results will follow.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
The incremental job mutates the whole of every source file a pull request
changes. For 0.20.0 that is 102 files and 1,639 mutants at about 20 s each; one
job over 4 threads needs about two hours against a 60-minute limit, and its
runner was stopped after 33 and 55 minutes in the two runs, with a handful of
survivors reported and the rest untested.

`mutants-incremental` is now a matrix of eight jobs, each running
`cargo mutants --shard k/8 --sharding round-robin` (mutant i goes to shard
i % 8, so the slow files spread over all of them; the default `slice` would
hand each shard a consecutive run in file order). Each shard runs the same
report gate as before and uploads its own artifact. A new job,
`mutants-incremental-gate`, is named "Mutation Testing (incremental)", the name
of the job it replaces, and fails unless every shard succeeded; it runs under
`always()` so a failed shard turns it red, since a skipped required check would
count as passed. `fail-fast` is off so one shard's survivor does not hide the
others'. The shard count is `strategy.job-total`, passed through `env:` like the
changed-file list, so the matrix and the command cannot disagree.

Checked locally with cargo-mutants 27.1.0 and the job's flags on a small
selection: shard 0/9 and shard 8/9 of 16 mutants ran two and one mutants, and
`mutants.json` in each lists only that shard's mutants; with 5 mutants over 9
shards shard 8/9 found none, exited 0 ("No mutants found under the active
filters"), and `scripts/mutants-report.sh incremental` accepted it (it fails an
empty run only in `full` mode). `actionlint`, `zizmor --offline`,
`check-workflow-expressions.py` and `check-action-pins.py` pass. Not run: the
workflow itself, so the eight-job matrix, the gate job and the artifact names
are untested until GitHub runs them; each shard of this pull request should
take about 205 mutants x 20 s / 4 = 17 minutes plus setup, an estimate from the
earlier job's timings. CONTRIBUTING.md describes the sharding and how to run
one shard locally.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
The first sharded run of the incremental mutation job (run 41067402973 on
adfde73) reported `bounds.rs:172:13` as a survivor: `size < 0` changed to
`size <= 0` in `list_view_entry` passed every unit test, because the tests
used only sizes of 1 and above and negatives. The new test checks the
boundary directly: (offset, size) of (0, 0), (0, 3), (3, 0), (i64::MAX, 0) and
(0, i64::MAX) are accepted, and (-1, 0), (0, -1), (i64::MIN, 0), (0, i64::MIN)
are refused.

`cargo mutants` with the job's flags on `list_view_entry`: 7 mutants, 7 caught
(the survivor among them). The other 101 survivors of that run are in the
description.yml YAML reader and are being worked separately.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…ue_len, and progress guards

The first sharded mutation run (run 41067402973 on adfde73) tested 1,617 mutants
and left 102 (85 missed, 17 timed out); 101 were in the YAML reader added in
this release. Working them from PyYAML 6.0.3's verdicts found three places
where the reader was wrong:

- A block scalar lost the lines after a blank line when the next line was a `#`
  line indented as far as the text: `description: |`, `l1`, a blank line and
  `# c` read as `l1`, PyYAML reads `l1\n\n# c\n`. `value_len` looked past every
  comment for the next content line. It is now a linear scan whose "run" is the
  blanks and the comments at the key's level or shallower, which also replaces
  the memo that made a run of k blank lines cost k^2 steps and drops a
  parameter (`seq_at_key_level`) that all three callers passed as `false`.
- An anchor on a line of its own followed by a sequence at the key's
  indentation (`k:\n  &a\n- x`) was refused; PyYAML reads `{k: [x]}`.
  `on_following_lines` forced `seq_at_key_level: false` on the value it
  re-parses; it keeps the key's.
- A quoted key was measured without the spaces before its colon, so a key
  PyYAML refuses at 1,024 characters was accepted. The measure is now to the
  colon, as for a plain key; the `check_code` call on the spaces before it is
  gone (a slice of spaces cannot fail it).

Checked with a three-way comparison (the original reader, the fixed one,
PyYAML `safe_load`) built from the final tree: on 16,195 mutated published
descriptors the two readers agree on every one and neither accepts a file
PyYAML refuses; on 624 grid documents around anchor lines and quoted keys of
1,020 to 1,025 characters the fix repairs 34 and breaks none; on 14,874
documents with block scalars, comment-like lines and plain, quoted and flow
values the `description` read equals PyYAML's wherever both accept (200
differed before), 474 more verdicts match and none matches less. The fixed
reader still refuses what PyYAML accepts in two cases, unchanged by this
commit: a tab-only content line in a block scalar, and a tag alone on a line
(`k:\n  !!str`). Regression tests: `tests_pyyaml.rs`, each fails on the
original reader and passes now.

The 17 timeouts were loops that spin when an index update is mutated. Each
loop (`skip`, `seq`, `map`, `plain` in flow.rs; `parse_mapping`, `parse_seq`
in block.rs; `split_lines`) now has a `debug_assert!` that a round made
progress, so the mutant fails where it used to hang; release builds are
unchanged. `split_comment` returns whether there is a comment instead of its
text, which no caller read (the `i * 1` mutant could not be told from the
original).

Local `cargo mutants` over the functions that changed or had survivors (195
mutants): 184 caught, 11 unviable, 0 missed, 0 timed out; `split_comment` and
`strip_comment`: 13 of 13 caught. 1,119 library tests, clippy and rustdoc clean,
`cargo +1.86.0 check` (with CI's fallback resolver) passes with and without
`duckdb-1-5-4`. The other mutants of those files are for the next sharded run.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…n left, and AUDIT 14.8

Four modules, `tests_mut_flow_a`, `tests_mut_flow_b`, `tests_mut_block` and
`tests_mut_scalar`, written by four engineers (subagents, each in its own
worktree) from the survivors of run 41067402973. Each row's expectation is
PyYAML 6.0.3's verdict, checked with `yaml.safe_load` / `yaml.compose`; rows
that pin the reader's own documented limits are commented as such (nesting of
64, no anchors in a field the reader reads, no explicit `? ` keys, error
wording where accept/refuse is identical). Each engineer ran `cargo mutants`
on its mutants before and after and reported the survivors that stayed.
Together with the regression tests of the previous commit they killed 79 of the
85 missed mutants; the other six were four equivalents (their code is gone) and
two PyYAML disagreements (fixed).

AUDIT.md 14.8 gains items 10 (the Miri time limit) and 11 (the mutation job and
what its first full run found), and 14.10 two lessons: random mutation of valid
files is weak at a hand-written parser's edges, and what made the delegated
sweep work.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
`typos` read the anchor name `anc` in tests_mut_flow_a.rs as a misspelling
of `and`; the anchor is now `k1` (PyYAML loads the document as
{'k1': 1, 'f': ['a', 1]}). The new tests_mut_*.rs modules were missing from
the source trees in CONTRIBUTING.md and book/src/contributing.md, which
documented_source_trees_match_the_filesystem compares with the filesystem.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…nd fit in 1,024 characters

Inside a flow collection PyYAML takes a node for a mapping key only if the
`:` after it is on the key's own line and at most 1,024 characters from where
the key began, an anchor in front of it included. Otherwise the `:` is left
with no key and the parser stops at it ("expected ',' or '}'"). The reader
checked neither, so `k: {a` with `b: c}` on the next line, `k: [a` with `b: c]`
on the next, `{"a"` with `: c}` on the next, and a key of 1,025 characters were
accepted in a section it only checks (and the mapping form in `extension:`).

Found by checking an engineer's remark that PyYAML refuses `[a` / `b: c]`:
the reader refused that file only because `extension:` takes no nested flow
collections. `Cursor::check_key_extent` measures from the key's first
character (a `(segment, offset)` taken before the node is read, so an anchor
counts) to the `:`, as the block-key check already does.

Checked with a differential harness against PyYAML 6.0.3: 30,120 documents
(random token soup over brackets, braces, quotes, anchors, aliases, colons and
line breaks, plus keys at the 1,024 boundary in both collections and for plain,
quoted and anchored keys) gave 109 disagreements before, every one a file only
PyYAML refuses, and none after, with none newly refused and no panic. Two new
tests in tests_pyyaml.rs (16 short rows, 30 boundary rows; expectations are
PyYAML's) fail on the old reader and pass on the new. `cargo mutants` on the
functions touched: 38 mutants, 38 caught. Local gates: tests 1,152 (default)
and 1,293 (`duckdb-1-5-4`), doc tests 235, clippy, fmt, typos, taplo, deny.

CHANGELOG (and the book copy) and AUDIT 14.8 item 11 record it.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
@tomtom215
tomtom215 merged commit 9ae1201 into main Oct 30, 2026
129 checks passed
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants