hashcodecs 1.1.0__tar.gz → 1.2.1__tar.gz

{hashcodecs-1.1.0 → hashcodecs-1.2.1}/BENCHMARK.md

@@ -16,14 +16,30 @@ sampling time per case is at least their product, plus calibration; use lower va
 hashcodecs-only pass, use `--hashcodecs-only --samples 3 --minimum-sample-seconds 0.05` with each Python benchmark
 script.
 
+## Python Call Costs
+
+Run `python benchmarks/python_calls.py` to measure positional calls from 0 through 256 bytes in nanoseconds per
+call. Use `--keywords` for positional and keyword calls at 64 bytes, or `--thresholds` for latency around the
+GIL-detachment cutoffs. The `--thread-scaling` mode measures aggregate throughput with one, two, and four threads;
+it does not pin the process to one logical CPU.
 
 ## XXH3
 
 For the Rust comparison, link hashcodecs with xxHash 0.8.3 through `xxhash-c-sys`. Build the C baseline with AVX2.
 For Python, run the upstream `xxhash` extension beside hashcodecs. Pass 32 equal-size inputs to each batch case.
+The Rust remainder cases pass two or three equal-size long inputs. Run Python remainder cases with
+`python benchmarks/python_xxhash.py --batch-counts 2 3`.
+
+Use the focused one-shot run to cover the AVX2 four-chain boundaries:
+
+```sh
+cargo bench --bench xxhash -- --sample-size 50 "xxh3_(64|128)/(241|512|768|1024|1536|2048|4096)/hashcodecs"
+```
 
 [![Rust XXH3 throughput](docs/benchmarks/xxh3-rust.svg)](docs/benchmarks/xxh3-rust.svg)
 
+[![Rust XXH3 batch remainder throughput](docs/benchmarks/xxh3-rust-batch-remainders.svg)](docs/benchmarks/xxh3-rust-batch-remainders.svg)
+
 [![Python XXH3 throughput](docs/benchmarks/xxh3-python.svg)](docs/benchmarks/xxh3-python.svg)
 
 ## Reusable Python Buffers
@@ -32,9 +48,18 @@ Pass one reusable `bytearray` to each `*_into` call.
 
 [![Reusable Python Base64 buffers](docs/benchmarks/base64-python-reusable.svg)](docs/benchmarks/base64-python-reusable.svg)
 
+## Lenient Python Base64
+
+Run `python benchmarks/python_base64.py --lenient`. The MIME cases insert CRLF after each 76-character line. The
+noisy cases insert `!` at the same boundaries. Both cases measure returned bytes and reusable output buffers.
+
+[![Lenient Python Base64 throughput](docs/benchmarks/base64-python-lenient.svg)](docs/benchmarks/base64-python-lenient.svg)
+
 ## Python Memoryview Inputs
 
-Use full immutable memoryviews for inputs of at least 64 KiB.
+Use `--memoryview-input` for full immutable views and `--sliced-memoryview-input` for equal-length views with a
+nonzero starting offset. The latter covers the copy/stabilization path used by slices while keeping the encoded data
+identical.
 
 [![Python Base64 memoryview inputs](docs/benchmarks/base64-python-memoryview.svg)](docs/benchmarks/base64-python-memoryview.svg)
 
@@ -44,6 +69,30 @@ Set the horizontal axis to batch size. Read total input throughput on the vertic
 
 [![Python Base64 batch throughput](docs/benchmarks/base64-python-batch.svg)](docs/benchmarks/base64-python-batch.svg)
 
+For focused runs, override the item and batch sizes directly. `--decode-only` avoids carrying encode allocator state
+into a decode investigation:
+
+```sh
+python benchmarks/python_base64_batch.py --item-sizes 4096 --batch-sizes 512 768 1024 1280 2048 --decode-only
+```
+
+Use a single operation when recording a sampling profile, or compare traced allocations without a sampler:
+
+```sh
+python benchmarks/python_base64_batch.py --item-sizes 4096 --batch-sizes 1024 --profile-operation returned
+python benchmarks/python_base64_batch.py --item-sizes 4096 --batch-sizes 1024 --allocation-profile
+```
+
+Add `--profile-direction encode` for returned encoding. By default, the profiling loop assigns the next result
+before releasing the previous one. Add `--discard-profile-result` to release each result before the next call. Use
+`b64encode_batch_into` for that workload.
+
+```sh
+python benchmarks/python_base64_batch.py --item-sizes 4096 --batch-sizes 1024 --profile-direction encode --profile-operation returned
+python benchmarks/python_base64_batch.py --item-sizes 4096 --batch-sizes 1024 --profile-direction encode --profile-operation returned --discard-profile-result
+python benchmarks/python_base64_batch.py --item-sizes 4096 --batch-sizes 1024 --profile-direction encode --allocation-profile
+```
+
 ## Reusable Python Base64 Batch Buffers
 
 Pass one reusable `bytearray` to each item in the batch. Use the `*_batch_into` APIs.

{hashcodecs-1.1.0 → hashcodecs-1.2.1}/CHANGELOG.md

@@ -4,6 +4,34 @@ This file records notable user-facing changes to `hashcodecs`. Version 1.0.0 sta
 
 ## [Unreleased]
 
+## [1.2.1] - 2026-08-26
+
+### What's Changed
+* fix: harden buffer and lenient decode paths by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/58
+* Refactor Murmur SIMD and centralize XXH3 long dispatch by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/59
+* Repair sdist verification and roll back unpublished 1.2.1 by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/60
+
+
+**Full Changelog**: https://github.com/kozistr/hashcodecs-rs/compare/v1.2.0...v1.2.1
+
+## [1.2.0] - 2026-08-25
+
+### What's Changed
+* fix: harden free-threaded bindings and API correctness by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/47
+* feat: accelerate Python batch outputs by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/48
+* feat: add native lenient Base64 decoding by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/49
+* update: tune Python detach thresholds by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/50
+* fix: harden Base64 binding edge cases by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/51
+* fix: stabilize Base64 GIL release test by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/52
+* feat: accelerate XXH3 batch remainders by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/53
+* perf: refresh Base64 batch benchmarks by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/54
+* perf: accelerate XXH3 long inputs by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/55
+* perf: profile Base64 batch allocations by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/56
+* refactor: organize Python binding infrastructure by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/57
+
+
+**Full Changelog**: https://github.com/kozistr/hashcodecs-rs/compare/v1.1.0...v1.2.0
+
 ## [1.1.0] - 2026-08-23
 
 ### What's Changed
@@ -99,7 +127,9 @@ This file records notable user-facing changes to `hashcodecs`. Version 1.0.0 sta
 - Initial Python and Rust APIs for Base64 and MurmurHash3.
 - Runtime SIMD dispatch and platform-specific CPython wheels.
 
-[Unreleased]: https://github.com/kozistr/hashcodecs-rs/compare/v1.1.0...HEAD
+[Unreleased]: https://github.com/kozistr/hashcodecs-rs/compare/v1.2.1...HEAD
+[1.2.1]: https://github.com/kozistr/hashcodecs-rs/compare/v1.2.0...v1.2.1
+[1.2.0]: https://github.com/kozistr/hashcodecs-rs/compare/v1.1.0...v1.2.0
 [1.1.0]: https://github.com/kozistr/hashcodecs-rs/compare/v1.0.0...v1.1.0
 [1.0.0]: https://github.com/kozistr/hashcodecs-rs/compare/v0.6.1...v1.0.0
 [0.6.1]: https://github.com/kozistr/hashcodecs-rs/compare/v0.6.0...v0.6.1

{hashcodecs-1.1.0 → hashcodecs-1.2.1}/CITATION.cff

@@ -5,8 +5,8 @@ authors:
     given-names: Hyeongchan
     orcid: https://orcid.org/0000-0002-1729-0580
 title: "hashcodecs: SIMD-accelerated Base64, MurmurHash3, and XXH3 for Python and Rust"
-version: 1.1.0
-date-released: 2026-08-23
+version: 1.2.1
+date-released: 2026-08-26
 license: "MIT OR Apache-2.0"
 repository-code: "https://github.com/kozistr/hashcodecs-rs"
-url: "https://github.com/kozistr/hashcodecs-rs"
+url: "https://github.com/kozistr/hashcodecs-rs"

{hashcodecs-1.1.0 → hashcodecs-1.2.1}/Cargo.lock

@@ -194,7 +194,7 @@ dependencies = [
 
 [[package]]
 name = "hashcodecs"
-version = "1.1.0"
+version = "1.2.1"
 dependencies = [
  "base64",
  "base64-turbo",

{hashcodecs-1.1.0 → hashcodecs-1.2.1}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "hashcodecs"
-version = "1.1.0"
+version = "1.2.1"
 edition = "2024"
 rust-version = "1.89"
 description = "SIMD-accelerated Base64 codecs and fast MurmurHash3 and xxHash implementations"
@@ -36,16 +36,16 @@ pyo3 = { version = "0.29.2", optional = true }
 pyo3-build-config = { version = "0.29.2", optional = true }
 
 [dev-dependencies]
-base64 = "0.23.1"
-base64-turbo = "0.3.0"
-criterion = { version = "0.8.2", default-features = false, features = ["cargo_bench_support"] }
-fastmurmur3 = "0.2.0"
-mimalloc = "0.1.52"
-mm3h = "0.1.3"
-murmur3 = "0.5"
-murmurs = "1.0.5"
-xxhash-c-sys = "0.8.7"
-xxhash-rust = { version = "0.8.18", features = ["xxh3"] }
+base64 = "=0.23.1"
+base64-turbo = "=0.3.0"
+criterion = { version = "=0.8.2", default-features = false, features = ["cargo_bench_support"] }
+fastmurmur3 = "=0.2.0"
+mimalloc = "=0.1.52"
+mm3h = "=0.1.3"
+murmur3 = "=0.5.2"
+murmurs = "=1.0.5"
+xxhash-c-sys = "=0.8.7"
+xxhash-rust = { version = "=0.8.18", features = ["xxh3"] }
 
 [[bench]]
 name = "base64"

{hashcodecs-1.1.0 → hashcodecs-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hashcodecs
-Version: 1.1.0
+Version: 1.2.1
 Summary: SIMD-accelerated Base64, MurmurHash3, and xxHash codecs
 Project-URL: Documentation, https://hashcodecs-rs.readthedocs.io/
 Project-URL: Repository, https://github.com/kozistr/hashcodecs-rs
@@ -41,6 +41,12 @@ Description-Content-Type: text/markdown
 ![Total Downloads](https://img.shields.io/pepy/dt/hashcodecs?style=for-the-badge&label=Total%20Downloads)
 ![Monthly Downloads](https://img.shields.io/pypi/dm/hashcodecs?style=for-the-badge&label=Monthly%20downloads)
 
+<p align="center">
+  <a href="BENCHMARK.md">
+    <img src="docs/benchmarks/performance-at-a-glance.svg" alt="CPython 3.12 URL-safe Base64 encoding and decoding benchmark">
+  </a>
+</p>
+
 SIMD-accelerated Base64, MurmurHash3, and XXH3 for Python and Rust.
 
 Move byte-heavy work into Rust without changing your Python inputs. `hashcodecs` accepts `bytes`, `bytearray`, and
@@ -144,7 +150,7 @@ assert_eq!(
 
 ## Architecture
 
-The Rust core owns algorithm behavior and SIMD dispatch. A thin CPython layer handles argument parsing, buffer
+The Rust core owns algorithm behavior and SIMD dispatch. A substantial CPython layer handles argument parsing, buffer
 ownership, reusable outputs, and GIL decisions; root-level Python modules provide typed public exports without
 adding per-call wrappers.
 
@@ -207,12 +213,13 @@ cargo bench --bench xxhash
 uv sync --group benchmark --no-install-project
 uv run --no-project --with . python benchmarks/python_base64.py
 uv run --no-project --with . python benchmarks/python_base64_batch.py
+uv run --no-project --with . python benchmarks/python_calls.py
 uv run --no-project --with . python benchmarks/python_murmur3.py
 uv run --no-project --with . python benchmarks/python_xxhash.py
 ```
 
-The Python benchmarks expose focused modes such as `--into`, `--bytearray-input`, `--memoryview-input`,
-`--incremental`, `--large`, and `--hashcodecs-only`. All scripts also accept `--samples` and
+The Python benchmarks expose focused modes such as `--into`, `--lenient`, `--bytearray-input`, `--memoryview-input`,
+`--sliced-memoryview-input`, `--incremental`, `--large`, and `--hashcodecs-only`. All scripts also accept `--samples` and
 `--minimum-sample-seconds`; use `--help` on a benchmark script for its supported modes and defaults.
 
 For the same-ISA Windows XXH3 comparison shown above, rebuild the C baseline with:

{hashcodecs-1.1.0 → hashcodecs-1.2.1}/README.md

@@ -10,6 +10,12 @@
 ![Total Downloads](https://img.shields.io/pepy/dt/hashcodecs?style=for-the-badge&label=Total%20Downloads)
 ![Monthly Downloads](https://img.shields.io/pypi/dm/hashcodecs?style=for-the-badge&label=Monthly%20downloads)
 
+<p align="center">
+  <a href="BENCHMARK.md">
+    <img src="docs/benchmarks/performance-at-a-glance.svg" alt="CPython 3.12 URL-safe Base64 encoding and decoding benchmark">
+  </a>
+</p>
+
 SIMD-accelerated Base64, MurmurHash3, and XXH3 for Python and Rust.
 
 Move byte-heavy work into Rust without changing your Python inputs. `hashcodecs` accepts `bytes`, `bytearray`, and
@@ -113,7 +119,7 @@ assert_eq!(
 
 ## Architecture
 
-The Rust core owns algorithm behavior and SIMD dispatch. A thin CPython layer handles argument parsing, buffer
+The Rust core owns algorithm behavior and SIMD dispatch. A substantial CPython layer handles argument parsing, buffer
 ownership, reusable outputs, and GIL decisions; root-level Python modules provide typed public exports without
 adding per-call wrappers.
 
@@ -176,12 +182,13 @@ cargo bench --bench xxhash
 uv sync --group benchmark --no-install-project
 uv run --no-project --with . python benchmarks/python_base64.py
 uv run --no-project --with . python benchmarks/python_base64_batch.py
+uv run --no-project --with . python benchmarks/python_calls.py
 uv run --no-project --with . python benchmarks/python_murmur3.py
 uv run --no-project --with . python benchmarks/python_xxhash.py
 ```
 
-The Python benchmarks expose focused modes such as `--into`, `--bytearray-input`, `--memoryview-input`,
-`--incremental`, `--large`, and `--hashcodecs-only`. All scripts also accept `--samples` and
+The Python benchmarks expose focused modes such as `--into`, `--lenient`, `--bytearray-input`, `--memoryview-input`,
+`--sliced-memoryview-input`, `--incremental`, `--large`, and `--hashcodecs-only`. All scripts also accept `--samples` and
 `--minimum-sample-seconds`; use `--help` on a benchmark script for its supported modes and defaults.
 
 For the same-ISA Windows XXH3 comparison shown above, rebuild the C baseline with:

{hashcodecs-1.1.0 → hashcodecs-1.2.1}/benches/xxhash.rs

@@ -6,7 +6,18 @@ use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_m
 
 mod support;
 
-const SIZES: [usize; 5] = [64, 1024, 4 * 1024, 1024 * 1024, 8 * 1024 * 1024];
+const SIZES: [usize; 10] = [
+    64,
+    241,
+    512,
+    768,
+    1024,
+    1536,
+    2048,
+    4 * 1024,
+    1024 * 1024,
+    8 * 1024 * 1024,
+];
 
 fn data(size: usize, salt: u8) -> Vec<u8> {
     (0..size)
@@ -61,52 +72,55 @@ fn one_shot(c: &mut Criterion) {
 }
 
 fn batch(c: &mut Criterion) {
-    const ITEMS: usize = 32;
-    for size in [64, 1024, 4 * 1024, 1024 * 1024] {
-        let owned = (0..ITEMS)
-            .map(|index| data(size, index as u8))
-            .collect::<Vec<_>>();
-        let inputs = owned.iter().map(Vec::as_slice).collect::<Vec<_>>();
-        let mut group = c.benchmark_group(format!("xxh3_batch/{size}"));
-        group.throughput(Throughput::Bytes((size * ITEMS) as u64));
+    for items in [2, 3, 32] {
+        for size in [64, 1024, 4 * 1024, 1024 * 1024] {
+            let owned = (0..items)
+                .map(|index| data(size, index as u8))
+                .collect::<Vec<_>>();
+            let inputs = owned.iter().map(Vec::as_slice).collect::<Vec<_>>();
+            let mut group = c.benchmark_group(format!("xxh3_batch/{items}_items/{size}"));
+            group.throughput(Throughput::Bytes((size * items) as u64));
 
-        group.bench_with_input(
-            BenchmarkId::new("hashcodecs_64", ITEMS),
-            &inputs,
-            |bench, inputs| bench.iter(|| hashcodecs::xxhash::xxh3_64_batch(black_box(inputs), 42)),
-        );
-        group.bench_with_input(
-            BenchmarkId::new("upstream_c_64", ITEMS),
-            &inputs,
-            |bench, inputs| {
-                bench.iter(|| {
-                    inputs
-                        .iter()
-                        .map(|input| c_xxh3_64(black_box(input), 42))
-                        .collect::<Vec<_>>()
-                })
-            },
-        );
-        group.bench_with_input(
-            BenchmarkId::new("hashcodecs_128", ITEMS),
-            &inputs,
-            |bench, inputs| {
-                bench.iter(|| hashcodecs::xxhash::xxh3_128_batch(black_box(inputs), 42))
-            },
-        );
-        group.bench_with_input(
-            BenchmarkId::new("upstream_c_128", ITEMS),
-            &inputs,
-            |bench, inputs| {
-                bench.iter(|| {
-                    inputs
-                        .iter()
-                        .map(|input| c_xxh3_128(black_box(input), 42))
-                        .collect::<Vec<_>>()
-                })
-            },
-        );
-        group.finish();
+            group.bench_with_input(
+                BenchmarkId::new("hashcodecs_64", items),
+                &inputs,
+                |bench, inputs| {
+                    bench.iter(|| hashcodecs::xxhash::xxh3_64_batch(black_box(inputs), 42))
+                },
+            );
+            group.bench_with_input(
+                BenchmarkId::new("upstream_c_64", items),
+                &inputs,
+                |bench, inputs| {
+                    bench.iter(|| {
+                        inputs
+                            .iter()
+                            .map(|input| c_xxh3_64(black_box(input), 42))
+                            .collect::<Vec<_>>()
+                    })
+                },
+            );
+            group.bench_with_input(
+                BenchmarkId::new("hashcodecs_128", items),
+                &inputs,
+                |bench, inputs| {
+                    bench.iter(|| hashcodecs::xxhash::xxh3_128_batch(black_box(inputs), 42))
+                },
+            );
+            group.bench_with_input(
+                BenchmarkId::new("upstream_c_128", items),
+                &inputs,
+                |bench, inputs| {
+                    bench.iter(|| {
+                        inputs
+                            .iter()
+                            .map(|input| c_xxh3_128(black_box(input), 42))
+                            .collect::<Vec<_>>()
+                    })
+                },
+            );
+            group.finish();
+        }
     }
 }
 

{hashcodecs-1.1.0 → hashcodecs-1.2.1}/docs/ARCHITECTURE.md

@@ -1,6 +1,7 @@
 # Architecture
 
-`hashcodecs` is a Rust library with a thin CPython extension and a small Python facade. The design keeps
+`hashcodecs` is a Rust library with a substantial CPython compatibility layer and a small Python facade. The
+design keeps
 algorithm correctness, CPU-specific execution, and language bindings separate so each layer can evolve without
 changing the others.
 
@@ -95,7 +96,14 @@ The API has three output models:
 
 - allocating functions return a new byte string or vector;
 - `*_into` functions write into caller-managed storage;
-- batch functions parse and validate the full operation before writing results.
+- allocating batch functions discard partial result lists on failure;
+- Base64 reusable-output batches are intentionally fail-fast and non-transactional;
+- the XXH3 binding validates and stabilizes every packed-batch input before it mutates the destination.
+
+The Python Base64 binding sends strict input to the SIMD core without constructing a discarded Python exception.
+For lenient input, it keeps the MIME whitespace path on normalized SIMD input and decodes other ignored bytes into
+the final Python object or reusable buffer. The native state machine follows the padding behavior of each supported
+CPython patch series. It calls `binascii` only when malformed input needs CPython's exact exception.
 
 Large aligned x86 encoding may use non-temporal stores after the input exceeds the detected private-cache working
 set. Smaller work stays on ordinary cached stores.
@@ -113,15 +121,22 @@ secret initialization, scheduling, accumulation, and merging. XXH3-64 and XXH3-1
 `long/{aarch64,avx2,avx512,ssse3}.rs` contains the ISA kernels beside the scalar long-input flow and its CPU
 selection. Only long inputs enter those kernels.
 
-Native batches reuse the initialized secret and process inputs in groups of four. Four equal-size inputs longer
-than 240 bytes use the AVX2 batch accumulator when available; mixed sizes and remainders use the regular paths.
+The AVX2 one-shot kernel splits each full 1,024-byte block across four accumulator chains. It also splits tails
+that contain at least four stripes, including the final overlapping stripe. The kernel reduces the chains before
+each block scramble and before the final merge.
+
+Native batches reuse the initialized secret and process inputs in groups of up to four. Two to four equal-size
+inputs longer than 240 bytes use an AVX2 batch accumulator when available; single items and mixed sizes use the
+regular paths.
 Python exposes two result models:
 
 - `xxh3_*_batch` returns ergonomic `list[int]` results;
 - `xxh3_*_batch_into` writes packed little-endian digests into one reusable `bytearray` and returns bytes written.
 
-The packed path hashes every input before mutating the destination. That makes validation failure atomic and
-allows the output bytearray to also appear as an input.
+The binding validates capacity and stabilizes every input before it mutates the destination. For small stable
+batches, it writes each infallible hash result to the packed output. For detached large batches and arbitrary
+exporters, it retains temporary results until hashing finishes; this fallback lets callers use the output bytearray
+as an input.
 
 ## CPython Boundary
 
@@ -137,7 +152,8 @@ Buffer handling follows ownership rather than treating every buffer alike:
 - exact `bytearray` values are borrowed but never used in detached work;
 - small or sliced memoryviews are copied;
 - full contiguous bytes or bytearray owners can be retained for large memoryviews;
-- immutable operations at or above 64 KiB may detach from the GIL;
+- immutable Base64 and XXH3 operations at or above 256 KiB may detach from the GIL;
+- immutable MurmurHash3 operations at or above 64 KiB may detach from the GIL;
 - mutable storage never crosses a detached region.
 
 Allocating outputs are initialized directly in CPython-owned memory. Reusable-output APIs validate capacity before
@@ -145,13 +161,19 @@ writing and preserve bytes beyond the returned length.
 
 ## Python Package
 
-The root `hashcodecs/` package is the canonical Python source. `_hashcodecs` contains the native extension surface;
-`base64.py`, `murmur3.py`, and `xxhash.py` organize exports without adding per-call wrappers. `_hashcodecs.pyi` and
-`py.typed` make the native API visible to type checkers.
+The typed `_hashcodecs.pyi` declaration is the canonical Python API description. It drives the public modules,
+package exports, module stubs, native text signatures and docstrings, and API-reference member lists through
+`tools/generate_api_metadata.py`. The generated `base64.py`, `murmur3.py`, and `xxhash.py` modules organize exports
+without adding per-call wrappers. `py.typed` makes the declarations visible to type checkers.
 
 Wheel tests execute the installed package, while coverage paths map that installed location back to the root source
 package.
 
+The 100% Rust line-coverage gate continues to measure the Rust core without default features. Separate Linux
+coverage jobs build instrumented CPython extensions for Python 3.12 and free-threaded Python 3.15, run the Python
+suite through them, and merge the binding-layer Rust coverage under a `rust-bindings` flag. The feature-gated
+binding layer remains outside the core percentage, the sanitizer jobs, Miri interpretation, and Kani proofs.
+
 ## Correctness and Safety
 
 Optimized kernels must remain interchangeable with the scalar baseline. The repository enforces that through:

{hashcodecs-1.1.0 → hashcodecs-1.2.1}/docs/api/base64.md

@@ -1,33 +1,33 @@
 # Base64 API Reference
 
-The functions below are rendered from the public API declarations. They describe the exact call signatures and
-behavior exposed by `hashcodecs.base64`.
+The functions below are rendered from the authoritative typed API declaration. They describe the exact call signatures
+and behavior exposed by `hashcodecs.base64`.
 
 ::: hashcodecs._hashcodecs
     options:
       members:
-        - b64encode
-        - b64encode_batch
-        - b64encode_batch_into
-        - b64encode_into
         - b64decode
         - b64decode_batch
         - b64decode_batch_into
         - b64decode_into
-        - standard_b64encode
-        - standard_b64encode_into
+        - b64encode
+        - b64encode_batch
+        - b64encode_batch_into
+        - b64encode_into
         - standard_b64decode
+        - standard_b64decode_batch
+        - standard_b64decode_batch_into
         - standard_b64decode_into
+        - standard_b64encode
         - standard_b64encode_batch
         - standard_b64encode_batch_into
-        - standard_b64decode_batch
-        - standard_b64decode_batch_into
-        - urlsafe_b64encode
-        - urlsafe_b64encode_into
+        - standard_b64encode_into
         - urlsafe_b64decode
+        - urlsafe_b64decode_batch
+        - urlsafe_b64decode_batch_into
         - urlsafe_b64decode_into
+        - urlsafe_b64encode
         - urlsafe_b64encode_batch
         - urlsafe_b64encode_batch_into
-        - urlsafe_b64decode_batch
-        - urlsafe_b64decode_batch_into
+        - urlsafe_b64encode_into
       show_root_heading: false

{hashcodecs-1.1.0 → hashcodecs-1.2.1}/docs/api/murmur3.md

@@ -1,14 +1,14 @@
 # MurmurHash3 API Reference
 
-The functions and incremental hashers below are rendered from the public API declarations.
+The functions and incremental hashers below are rendered from the authoritative typed API declaration.
 
 ::: hashcodecs._hashcodecs
     options:
       members:
         - murmur3_32
-        - murmur3_x86_128_digest
+        - murmur3_x64_128
         - murmur3_x64_128_digest
         - murmur3_x86_32
         - murmur3_x86_128
-        - murmur3_x64_128
+        - murmur3_x86_128_digest
       show_root_heading: false

{hashcodecs-1.1.0 → hashcodecs-1.2.1}/docs/api/xxh3.md

@@ -1,14 +1,14 @@
 # XXH3 API Reference
 
-The functions below are rendered from the public API declarations.
+The functions below are rendered from the authoritative typed API declaration.
 
 ::: hashcodecs._hashcodecs
     options:
       members:
         - xxh3_64
-        - xxh3_128
         - xxh3_64_batch
         - xxh3_64_batch_into
+        - xxh3_128
         - xxh3_128_batch
         - xxh3_128_batch_into
       show_root_heading: false

{hashcodecs-1.1.0 → hashcodecs-1.2.1}/docs/base64.md

@@ -30,10 +30,12 @@ The `standard_b64encode` and `urlsafe_b64encode` helpers select the respective a
 
 ## Decoding and Validation
 
-`b64decode(s, altchars=None, validate=False, *, padded=True, ignorechars=..., canonical=False)` decodes an ASCII
+`b64decode(s, altchars=None, validate=..., *, padded=True, ignorechars=..., canonical=False)` decodes an ASCII
 string or bytes-like value.
 
 - `validate=True` rejects characters outside the chosen alphabet instead of discarding them.
+- If you supply `ignorechars` without `validate`, hashcodecs uses strict mode. Pass `validate=False` to keep lenient
+  mode; hashcodecs then limits discarded bytes to `ignorechars`.
 - `padded=False` accepts an unpadded final Base64 quantum.
 - `ignorechars` specifies which non-alphabet bytes lenient decoding may ignore. Its default preserves the standard
   library's lenient behavior.