Skip to content

chore(ci): bump the actions group across 1 directory with 3 updates - #145

Closed
dependabot[bot] wants to merge 1 commit into
mainfrom
dependabot/github_actions/actions-37e66268e9
Closed

dependabot[bot] wants to merge 1 commit into
mainfrom
dependabot/github_actions/actions-37e66268e9

Conversation

@dependabot

@dependabot dependabot Bot commented on behalf of github Oct 26, 2026 •

Copy link
Copy Markdown
Contributor

Bumps the actions group with 3 updates in the / directory: dtolnay/rust-toolchain, Swatinem/rust-cache and rust-lang/crates-io-auth-action.

Updates dtolnay/rust-toolchain from e2a55d2ffb04f378e9626c28d38b36d230d1e12f to 683b588c487a69d01f6c6ddf40f036ff682cc2c8

Commits

Updates Swatinem/rust-cache from 2.9.2 to 2.9.3

Release notes

Sourced from Swatinem/rust-cache's releases.

v2.9.3

What's Changed

New Contributors

Full Changelog: Swatinem/rust-cache@v2.9.2...v2.9.3

Changelog

Sourced from Swatinem/rust-cache's changelog.

Changelog

2.9.3

  • Fix timestamp based pruning
  • Add missing awaits
  • Do not emit warning on missing rustup

2.9.2

  • Fix credentials.toml cleanup
  • Improvements to cleanup, preserving more valid targets
  • Improvements to cargo install handling
  • Correctly sort/dedupe Rust versions

2.9.1

  • Fix regression in hash calculation

2.9.0

  • Update to node24
  • Support running from within a nix shell
  • Consider all installed toolchains for cache key
  • Use case-insensitive comparison to determine exact cache hit

2.8.2

  • Don't overwrite env for cargo-metadata call

2.8.1

  • Set empty CARGO_ENCODED_RUSTFLAGS when retrieving metadata
  • Various dependency updates

2.8.0

  • Add support for warpbuild cache provider
  • Add new cache-workspace-crates feature

2.7.8

  • Include CPU arch in the cache key

2.7.7

  • Also cache cargo install metadata

2.7.6

... (truncated)

Commits
  • d1527c8 2.9.3
  • f0fca6f update dependencies and rebuild
  • b49b17f add missing awaits
  • 6a7bc3e Bump the dev-minor group across 1 directory with 2 updates (#383)
  • 4ece996 Bump the actions group across 1 directory with 6 updates (#392)
  • 8103aff Bump the prd-minor group across 1 directory with 2 updates (#389)
  • 0e361f3 fix: log rustup toolchain list failure as info instead of warning (#393) (#394)
  • f0d9c38 Merge pull request #380 from Swatinem/dependabot/github_actions/actions-8ff58...
  • ccd9742 Bump the actions group with 2 updates
  • 258712b fix: stop cleanup timestamp pruning after the first entry (#377)
  • Additional commits viewable in compare view

Updates rust-lang/crates-io-auth-action from 1.0.5 to 1.0.6

Release notes

Sourced from rust-lang/crates-io-auth-action's releases.

v1.0.6

What's Changed

update dependencies

Full Changelog: rust-lang/crates-io-auth-action@v1.0.5...v1.0.6

Commits
  • 3268eb4 Merge pull request #278 from marcoienibot/chore/update-dependencies-2026-10
  • e901356 chore(deps): update dependencies and GitHub Actions
  • 9c067fc Merge pull request #277 from rust-lang/renovate/msw-3.x
  • 9b55005 chore(deps): update dependency msw to v3
  • 4920f09 Merge pull request #276 from rust-lang/renovate/major-github-actions
  • 04dcccb chore(deps): update github actions
  • 82864bf Merge pull request #274 from rust-lang/renovate/major-vitest-monorepo
  • 2bd8e07 chore(deps): update dependency vitest to v5
  • f14f407 Merge pull request #271 from rust-lang/renovate/github-actions
  • 0205d6c chore(deps): update github actions
  • Additional commits viewable in compare view

@dependabot
dependabot Bot requested a review from tomtom215 as a code owner October 26, 2026 06:32
@dependabot @github

dependabot Bot commented on behalf of github Oct 26, 2026

Copy link
Copy Markdown
Contributor Author

Labels

The following labels could not be found: dependencies, github-actions. Please create them before Dependabot can add them to a pull request.

Please fix the above issues or remove invalid values from dependabot.yml.

Bumps the actions group with 3 updates in the / directory: [dtolnay/rust-toolchain](https://github.com/dtolnay/rust-toolchain), [Swatinem/rust-cache](https://github.com/swatinem/rust-cache) and [rust-lang/crates-io-auth-action](https://github.com/rust-lang/crates-io-auth-action).


Updates `dtolnay/rust-toolchain` from e2a55d2ffb04f378e9626c28d38b36d230d1e12f to 683b588c487a69d01f6c6ddf40f036ff682cc2c8
- [Release notes](https://github.com/dtolnay/rust-toolchain/releases)
- [Commits](dtolnay/rust-toolchain@e2a55d2...683b588)

Updates `Swatinem/rust-cache` from 2.9.2 to 2.9.3
- [Release notes](https://github.com/swatinem/rust-cache/releases)
- [Changelog](https://github.com/Swatinem/rust-cache/blob/master/CHANGELOG.md)
- [Commits](Swatinem/rust-cache@6323deb...d1527c8)

Updates `rust-lang/crates-io-auth-action` from 1.0.5 to 1.0.6
- [Release notes](https://github.com/rust-lang/crates-io-auth-action/releases)
- [Commits](rust-lang/crates-io-auth-action@c6f97d4...3268eb4)

---
updated-dependencies:
- dependency-name: dtolnay/rust-toolchain
  dependency-version: 683b588c487a69d01f6c6ddf40f036ff682cc2c8
  dependency-type: direct:production
  dependency-group: actions
- dependency-name: rust-lang/crates-io-auth-action
  dependency-version: 1.0.6
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: actions
- dependency-name: Swatinem/rust-cache
  dependency-version: 2.9.3
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: actions
...

Signed-off-by: dependabot[bot] <support@github.com>
@dependabot
dependabot Bot force-pushed the dependabot/github_actions/actions-37e66268e9 branch from 7951922 to d8249bb Compare October 29, 2026 12:13
tomtom215 pushed a commit that referenced this pull request Oct 30, 2026
… 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).
tomtom215 pushed a commit that referenced this pull request Oct 30, 2026
Merges the 19 commits of the infra implementation agent (eighth review): the
upstream-guard wrapper, a hardened CI aggregate check, release-metadata and
--locked dry-run checks, release.yml hardening (crate hash checked before
upload), an actionlint job, a hygiene job (typos, taplo, machete, the deny
matrix over the CI-only graphs), the exact toolchain pin with an informational
latest-stable job, the Dependabot #145 action bumps, a corrected API-coverage
script, SECURITY.md and RELEASING.md corrections, and the sanitizer
blind-spot documentation. Details: AUDIT.md section 14.

Known to fail until the scaffold and api work packages merge: check-action-pins.py
(the scaffold's templates_ci.rs pins) and check-api-coverage.py (duckdb_open and
duckdb_close are not yet in the allowlist).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
tomtom215 added a commit that referenced this pull request Oct 30, 2026
…150)

* Fix the ListBuilder entry-array regression and five smaller issues found 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

* Cap the DuckDB bindings range below 2.1 and ship an allow-list package

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

* ci: run the six upstream-comparison guards through scripts/upstream-guard.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.

* inline_paths: use lambda syntax DuckDB 2.0.0 accepts (identical to the 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.

* ci: check-ci-aggregate.py no longer passes while a gate is removed (CI-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).

* Use the new lambda syntax in the ListBuilder regression test's oracle

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

* ci: a release commit with a stale lockfile now fails in minutes, not 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.

* release: compare the .crate with the attested hash before uploading it; 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.

* ChunkWriter: count claimed rows honestly and add release_row (UNSOUND-1)

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]).

* ci: lint every workflow with actionlint, checksum-pinned (CI-11)

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.

* ci: cache examples/hello-ext's own target dir in the three jobs that 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.

* ci: scaffold-compile cannot pass by running zero tests (CI-8)

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).

* docs: README front page, libduckdb-sys range, 0.20 snippets, DuckDB 2.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).

* arrow import: refuse offsets, lengths and indices DuckDB reads out of 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.

* ci: pin the Rust toolchain to 1.99.1; an informational job tracks the 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).

* ci: fold in Dependabot #145 by hand; check the scaffold's action pins 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).

* Cap type-nesting walks and clamp the cardinality hint (HARDEN-6, HARDEN-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 ...".

* repo: typos, taplo and editorconfig configs; cargo-deny config for the 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.

* ci: a `hygiene` job (typos, taplo, cargo-machete) and cargo-deny over 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.

* repo: clippy.toml says its three thresholds are clippy's defaults (DEPS-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.

* Overload guard: compare types the way DuckDB resolves overloads (AUTHT2-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.

* scripts: check-api-coverage.py counts only library code as wrapping a 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.

* Let closure-built scalars be overloads of a set: overload_typed (AUTHT2-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.

* scripts: two upstream guards no longer pass on a reshaped upstream (CI-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).

* docs: correct the author-review findings (bind cannot set a return type, 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).

* docs: pitfalls L20, L21, P16, P17 and the corrected L3/L11, known-limitations 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).

* docs: community-extension conformance in publishing.md (reserved names, 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;.

* docs: SECURITY.md's supported versions are true for 0.20.0; MIN_RELEASE 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).

* Scalar bind data: report a panicking Clone, free a replaced value (FFI-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).

* docs: RELEASING.md matches what release.yml does: lockfiles, hotfix flow, 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.

* docs: CONTRIBUTING states the sanitizer blind spot, the toolchain policy and DuckDB 2.0's agent mode; README/CONTRIBUTING match the workflows (LASTDIFF-3, CI-3, CI-15)

What was wrong:
- (LASTDIFF-3) The sanitizer jobs were described as answering "did we
  write outside an allocation"; the release libduckdb they link takes
  vector data buffers, LIST entry arrays and string heaps from its own
  jemalloc, which neither valgrind nor ASAN tracks, so a stale or
  out-of-bounds write there is invisible to them (the lastdiff reviewer's
  LASTDIFF-1 regression drew no valgrind report).
- (CI-3) Nothing told a contributor that the toolchain is pinned, why, or
  how to move it; CONTRIBUTING said `rust-toolchain.toml` pins "stable",
  and "Python 3, any current" although two scripts now need tomllib (3.11).
- DuckDB 2.0's CLI changes its output format when AI_AGENT or CLAUDECODE
  is set and stdout is not a terminal; nothing said so.
- (CI-15, Appendix F) the workflows README did not mention the pre-upload
  hash check, listed benchmarks' triggers loosely, and did not say what
  check-ci-aggregate.py enforces now; CONTRIBUTING said CI runs "on every
  push"; the new hygiene/workflow-lint gates and the CI-crates deny run
  had no local command.

Change: CONTRIBUTING gets "The Rust toolchain" (pin, exceptions, the
informational look-ahead jobs, a three-step bump procedure) and "What the
sanitizer and valgrind runs can and cannot see"; prerequisites name the
pinned release, Python 3.11+, the hygiene tool versions, and the agent
mode with the format flags that work (`-csv`/`-json` everywhere,
`-no-agent` on 2.0 only); gate 6's toolchain sentence; gates 8 and 8b.
The workflows README gets a "Pinning, and the checks that hold it" table
and the upstream-guard semantics, the corrected rows, and two new steps
for adding a workflow. ci.yml: comments only, on the leak-check and asan
jobs, stating the blind spot (the jobs' steps are unchanged).

Ran: `nm -D` on the release libduckdb.so: 769 `duckdb_je_*` exports at
v1.5.6, 768 at v2.0.0, and no exported malloc/free/calloc/realloc. The
DuckDB CLIs with AI_AGENT / CLAUDECODE set and stdout a pipe: 2.0.0 prints
"duckdb agent mode on: ..." and a Markdown table (`| answer:INTEGER |`),
`-csv` and `-json` override it, `-no-agent` restores the box; 1.5.6 shows
no agent mode and rejects `-no-agent` (exit 1). scripts/check-hello-ext.py
passes -csv (read). typos clean; actionlint clean; check-ci-aggregate
reads the README table (37 blocking jobs).
Not run: valgrind or ASAN myself; the jemalloc blind spot for ASAN follows
from the same allocator (CONJECTURED for ASAN, VALIDATED for valgrind by
the lastdiff reviewer).

* docs: upgrade guide 0.18 -> 0.20, scaffold prerequisites, SQLLogicTest skip warning, README wrapped to 64 columns, governance reality

- book/src/getting-started/upgrading-0-20.md (new, in SUMMARY and sitemap):
  every row traced to a CHANGELOG bullet of 0.19.0 or [Unreleased]; the 0.19 ->
  0.20 section also covers the libduckdb-sys ceiling (<1.20100) and what a user
  of 0.18/0.19 can add themselves.
- README: every code line is now <= 64 columns (the crates.io content column
  clips at about 64; checked by rendering the README at crates.io's width), the
  comparison table is shortened so its third column is no longer cut off.
  The quick start (TOML + lib.rs taken from the README text, quack-rs by path)
  builds on stable and on 1.86.0 with `--locked`, stamps, and loads on DuckDB
  1.4.4, 1.5.6 and 2.0.0 with the printed table; double_it(9223372036854775807)
  is "Invalid Input Error: double_it: overflow".
- scaffold.md: the scaffold generator is an example in the repository, not in the
  published crate (`exclude` has examples/); prerequisites for `make configure`;
  `make` ignores CARGO_TARGET_DIR (author-tables review).
- testing.md: a SQLLogicTest file whose `require` fails is reported SKIPPED and
  exits 0 (conform review); the NULL example re…
@dependabot @github

dependabot Bot commented on behalf of github Oct 30, 2026

Copy link
Copy Markdown
Contributor Author

Looks like these dependencies are no longer updatable, so this is no longer needed.

@dependabot dependabot Bot closed this Oct 30, 2026
@dependabot
dependabot Bot deleted the dependabot/github_actions/actions-37e66268e9 branch October 30, 2026 18:15
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.

0 participants