Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@crates/uselesskey-bdd-steps/Cargo.toml`:
- Line 9: The crate's Cargo.toml currently has publish = true but this BDD
step-definitions crate appears to be test-only; either change publish = false in
Cargo.toml or, if you intend to publish, add version fields to the path-only
dependencies referenced in the manifest (the path deps currently missing
version) and add the crate name to the PUBLISH_CRATES list in xtask/src/main.rs
so it is validated by the publish preflight; update the publish flag or add the
required version attributes and PUBLISH_CRATES entry accordingly to make the
manifest consistent with publishing requirements.

In `@crates/uselesskey-bdd-steps/src/steps/core_id_steps.rs`:
- Line 31: Add an inline comment above the let domain: &'static str =
Box::leak(domain.into_boxed_str()); line in core_id_steps.rs documenting that
Box::leak is intentionally used to convert the runtime String to &'static str
because the library API (ArtifactDomain) requires a 'static lifetime; note that
this leaks memory per scenario but is bounded and acceptable in BDD tests, and
include a brief mention that changing the API to accept owned String or a
shorter lifetime would be an alternative if leaks were unacceptable.

In `@crates/uselesskey-bdd-steps/src/steps/core_keypair_steps.rs`:
- Around line 7-14: The DER and PEM constants (CORE_KEYPAIR_PKCS8_DER,
CORE_KEYPAIR_PKCS8_PEM, CORE_KEYPAIR_SPKI_DER, CORE_KEYPAIR_SPKI_PEM) are
synthetic and not binary-equivalent; add a short clarifying comment above these
constants stating that the PEM bodies do not decode to the shown DER values and
that these are independent dummy/sample blobs for testing only, so maintainers
won't assume they are paired encodings.
- Around line 99-103: The current assertion in core_keypair_kids_identical can
pass when both world.core_kid_first and world.core_kid_second are None; change
the test to first assert both Option fields are Some (fail with a clear message
if not), then compare their inner values for equality (e.g., unwrap or
pattern-match after the presence checks) so the step fails when KIDs were not
actually derived; reference function core_keypair_kids_identical and fields
core_kid_first/core_kid_second.

In `@crates/uselesskey-bdd-steps/src/steps/core_negative_steps.rs`:
- Around line 6-8: The two fixture constants CORE_NEGATIVE_PEM_FIXTURE and
CORE_NEGATIVE_DER_FIXTURE are only used under the uk-core-negative feature gate
so add #[cfg(feature = "uk-core-negative")] above each constant definition to
prevent dead-code warnings; locate the const declarations for
CORE_NEGATIVE_PEM_FIXTURE and CORE_NEGATIVE_DER_FIXTURE and annotate both with
the same feature attribute so they are compiled only when the uk-core-negative
feature is enabled.

In `@crates/uselesskey-bdd/Cargo.toml`:
- Line 19: The uk-all feature currently lists every individual step feature
explicitly; simplify it by keeping only the umbrella feature reference so uk-all
= ["uselesskey-bdd-steps/uk-all"] (remove the long list of individual features
such as "uselesskey-bdd-steps/uk-rsa", "uselesskey-bdd-steps/uk-ecdsa",
"uselesskey-bdd-steps/uk-ed25519", etc.), updating the uk-all entry to reference
only "uselesskey-bdd-steps/uk-all".

In `@crates/uselesskey-bdd/features/core-id.feature`:
- Around line 14-17: The Scenario title "domain and variant changes alter
output" is misleading because only the variant differs in the two When steps;
update the Scenario title in the core-id.feature to reflect what's actually
tested (for example change it to "variant change alters output" or "variant
changes alter output"), or alternatively add a new Scenario that varies the
domain (and use a clear title) so the original title remains accurate; locate
the scenario by its current title and the When steps that call derive a core-id
seed with domain "uselesskey:rsa:keypair" and variants "v1"/"v2" to make the
change.

In `@crates/uselesskey-bdd/features/core-keypair.feature`:
- Around line 20-21: The duplicated step text "When I derive a core-keypair kid"
should be made distinct to avoid implicit invocation-order coupling; change the
second occurrence to use the same "again" suffix pattern used elsewhere (e.g.,
"When I derive a core-keypair kid again") so the step definitions map
unambiguously to the first and second derivations and avoid fragile
counter-based behavior.

In `@crates/uselesskey-bdd/features/core-negative.feature`:
- Line 3: Fix the typo in the feature description by replacing the nonstandard
word "deterministicish" with a clearer term such as "deterministic-ish" (or
"deterministic-like") so the line reads e.g. "I want deterministic and
deterministic-ish PEM/DER corruption utilities"; update that phrase in the
feature text to ensure consistent, standard wording.
- Line 9: Rename the misleading step phrase to reflect the generic PKCS#8
fixture: change the feature step text "the deterministic RSA PEM artifact should
fail to parse" to something like "the corrupted PEM artifact should fail to
parse" and update the matching step definition string in the step implementation
so it still reads world.deterministic_text_1 (no code logic change). Ensure any
other scenarios referencing the old step name are updated to the new phrase so
the step binding (the step definition that reads world.deterministic_text_1)
continues to match.

In `@crates/uselesskey-bdd/tests/feature_contract.rs`:
- Around line 43-45: The condition in the loop uses a redundant check: inside
the block referencing trimmed.starts_with('[') the additional
!trimmed.is_empty() is unnecessary because starts_with implies non-empty; update
the condition in the code that contains trimmed.starts_with('[') to remove the
!trimmed.is_empty() guard so the if becomes simply trimmed.starts_with('[') to
simplify and clarify intent.

In `@crates/uselesskey-core-id/src/lib.rs`:
- Around line 144-148: The length-prefixing in write_len_prefixed is incorrect
because unwrap_or(u32::MAX) silently misrepresents sizes >= 2^32; change it to
enforce failure instead of clamping: validate that bytes.len() fits in a u32
(e.g., with debug_assert!(bytes.len() <= u32::MAX as usize) and then use
u32::try_from(bytes.len()).expect("...") or plain panic with a clear message),
then cast to u32 and write to_be_bytes as before; update the function
write_len_prefixed to perform this explicit check and fail fast on overflow
rather than using u32::MAX.
- Around line 119-125: Replace the stderr print in the unknown-derivation branch
with a structured logging call or remove it: instead of eprintln! in the match
arm that falls back to derive_seed_v1(master, id) (the branch matching `other`),
emit a warn-level log via the chosen logging crate (e.g., log::warn! or
tracing::warn!) behind a feature flag (e.g., feature = "log") or drop the
runtime diagnostic entirely and rely on docs; update Cargo features and
conditional compilation accordingly so the crate does not print to stderr from
library code.
- Around line 222-243: Replace the manual two-case test
`derive_seed_version_affects_output` with an rstest-parameterized test that
iterates different DerivationVersion values; locate the test function and change
it to use rstest's #[rstest] attribute (or #[rstest(param)] style) to supply
multiple DerivationVersion instances, construct the corresponding ArtifactId via
ArtifactId::new (keeping the same domain/label/spec/variant), call
derive_seed(&master, &id) for each version, and assert that outputs differ
between versions (e.g., by comparing bytes of different parameter pairs) so new
versions can be added by simply extending the rstest parameter list.

In `@crates/uselesskey-core-keypair/Cargo.toml`:
- Around line 16-18: The Cargo.toml is missing a [features] section to expose a
"std" feature that can be disabled and propagate to the transitive dependencies,
and it's missing dev-dependencies needed for tests; add a [features] section
that sets default = ["std"] and defines "std" =
["uselesskey-core/std","uselesskey-core-kid/std"] (so consumers can opt out of
std for uselesskey-core and uselesskey-core-kid), and add a [dev-dependencies]
section including proptest and rstest entries so tests that reference those
crates will build.

In `@crates/uselesskey-core-keypair/README.md`:
- Line 9: Update the README bullet to clarify that uselesskey-core-keypair
applies (does not provide) the deterministic negative fixture helpers from the
other crate: change the line describing "deterministic negative fixture helpers"
to something like "applies deterministic negative fixtures from
`uselesskey-core-negative` to key material" so it explicitly references
`uselesskey-core-negative` and states that core-keypair uses those corruption
primitives rather than owning them.

In `@crates/uselesskey-core-keypair/src/lib.rs`:
- Around line 105-178: Add property-based/parameterized tests using proptest or
rstest to increase coverage for functions like private_key_pkcs8_der_truncated
and private_key_pkcs8_pem_corrupt_deterministic; specifically, replace or
augment the fixed-value tests in the tests module (e.g.,
truncation_respects_requested_length and deterministic_corruption_is_stable)
with proptest strategies that generate arbitrary truncation lengths and
arbitrary corruption variant strings, assert invariants (requested length
respected, corruption deterministic across same variant), and also add
randomized checks for kid() stability and that
write_private_key_pkcs8_pem()/write_public_key_spki_pem() round-trip PEM markers
for a variety of sample_material inputs produced by parameterized fixtures or
proptest-generated byte/pem combinations.

In `@crates/uselesskey-core-negative/Cargo.toml`:
- Around line 24-26: Update the crate's feature propagation so the local "std"
feature enables the downstream dependency's std too: change the [features]
section to make std = ["uselesskey-core-id/std"] (so toggling
default-features=false correctly prevents the dependency's std feature), keeping
default = ["std"] as needed.

In `@crates/uselesskey-core-negative/src/lib.rs`:
- Around line 21-29: Add /// doc comments to the public API functions
corrupt_pem, corrupt_pem_deterministic, truncate_der, flip_byte, and
corrupt_der_deterministic explaining their purpose, parameters, return values,
and any determinism guarantees (i.e., which functions are deterministic vs
non-deterministic and how determinism is achieved). For each function include a
short example or note about the corruption semantics (e.g., what CorruptPem
variants do for corrupt_pem, how bytes/count are interpreted for truncate_der
and flip_byte) and mention error or boundary behavior (e.g., what happens if
bytes exceed input length). Ensure the comments use Rust doc style (///) placed
immediately above each function signature.
- Line 17: CorruptPem::Truncate { bytes } is misnamed because corrupt_pem uses
pem.chars().take(bytes) (counts Unicode scalar values); rename the enum variant
field to chars (e.g., CorruptPem::Truncate { chars }) and update corrupt_pem to
use the new field name, and update all callsites and pattern matches accordingly
so the name accurately reflects character-counting behavior; alternatively, if
you want true byte-truncation, change corrupt_pem to operate on pem.as_bytes()
and truncate by bytes and reconstruct a valid String (handling invalid UTF-8)
instead—pick one and apply consistently to CorruptPem::Truncate and corrupt_pem.
- Around line 174-265: Add proptest-based property tests per the guideline: add
proptest to dev-dependencies and in the tests module create property tests
(using proptest! or #[proptest]) that generate arbitrary non-trivial PEM strings
and variant keys and assert corrupt_pem_deterministic(pem, variant) != pem (and
similarly ensure corrupt_der_deterministic(&der, variant) != der for generated
DER byte vectors of length > 0), plus a property asserting determinism for the
same (pem/der, variant) pair; import and use proptest strategies for strings and
byte vectors and reference the existing functions corrupt_pem_deterministic,
corrupt_der_deterministic, and corrupt_pem in those tests.

In `@crates/uselesskey-core-sink/Cargo.toml`:
- Around line 1-21: Add an explicit publish = true field to the package manifest
for the crate named "uselesskey-core-sink" so the intent to allow publishing is
explicit and matches the other new crates (e.g., "uselesskey-feature-grid");
update the [package] section in Cargo.toml for that crate by adding publish =
true.

In `@crates/uselesskey-core-sink/src/lib.rs`:
- Around line 156-159: read_to_string currently uses String::from_utf8_lossy
which silently replaces invalid UTF-8; change it to perform strict UTF-8
conversion to match std semantics by calling String::from_utf8(bytes) and map
the Utf8Error into a std::io::Error (InvalidData) so read_to_string returns an
error on invalid UTF-8; update the implementation in the read_to_string function
to use the bytes from read_to_bytes and propagate conversion errors as
io::Error::new(std::io::ErrorKind::InvalidData, err) (alternatively, rename to
read_to_string_lossy if you prefer preserving lossy behavior, but prefer
matching std::fs::read_to_string).

In `@crates/uselesskey-core/src/id.rs`:
- Line 1: Remove the crate-level attribute #![cfg_attr(not(feature = "std"),
no_std)] from submodule files (the attribute appears at the top of the id module
and the negative::mod module); this attribute must only live in the root crate
module (lib.rs) so delete those lines in the id module (id.rs) and in
negative::mod (mod.rs) and then verify the crate still compiles with
--no-default-features to confirm the root-level no_std in lib.rs is used.

In `@crates/uselesskey-core/src/negative/mod.rs`:
- Line 1: Remove the crate-level attribute from module files: delete the line
`#![cfg_attr(not(feature = "std"), no_std)]` found at the top of the modules
(negative module in negative/mod.rs and the id module in id.rs) because this
attribute belongs only in the crate root (lib.rs); simply remove that attribute
from the negative::mod and the id module files and keep any necessary crate-root
attribute in lib.rs.

In `@crates/uselesskey-ecdsa/tests/jwk_private.rs`:
- Around line 12-14: Replace the fully-qualified call to
uselesskey_core_kid::kid_from_bytes(...) inside the expected_kid function with a
crate-level use import: add `use uselesskey_core_kid::kid_from_bytes;` near the
other imports and change the body of expected_kid(spki_der: &[u8]) to call
kid_from_bytes(spki_der); this keeps imports consistent with the rest of the
module and avoids the inline fully-qualified path.

In `@crates/uselesskey-ed25519/tests/jwk_private.rs`:
- Around line 12-14: Replace the inline fully-qualified call
uselesskey_core_kid::kid_from_bytes in the expected_kid function with a
top-level use import; add a line like use uselesskey_core_kid::kid_from_bytes;
at the top of the module and then call kid_from_bytes(spki_der) inside fn
expected_kid to match the other imports and keep consistency.

In `@crates/uselesskey-feature-grid/Cargo.toml`:
- Around line 17-20: Remove the empty [dependencies] and [dev-dependencies]
sections from Cargo.toml because they are unnecessary when no entries exist;
locate the literal section headers "[dependencies]" and "[dev-dependencies]" in
the file and delete those lines (and any blank lines directly associated) so the
manifest is cleaner and contains only populated sections.

In `@crates/uselesskey-feature-grid/README.md`:
- Around line 5-6: Update the README sentence that claims the crate contains
"only compile-time constants" to accurately reflect that it also exports a
struct type; specifically edit the description to mention both the compile-time
constants and the exported FeatureSet type (struct) used to keep xtask and BDD
automation aligned so readers know the crate provides constants plus the
FeatureSet API.

In `@crates/uselesskey-feature-grid/src/lib.rs`:
- Around line 114-124: BDD_FEATURE_MATRIX uses inline comma-separated feature
string literals in FeatureSet::new calls (e.g., "uk-all,uk-rustls") which won't
pick up changes to the UK_FEATURE_* constants; either add a brief comment above
BDD_FEATURE_MATRIX explaining Rust cannot concat &'static str at compile time so
these literals are intentional, or add a compile-time/unit test that parses each
FeatureSet string in BDD_FEATURE_MATRIX, splits on commas and asserts every
token is one of the canonical constants (UK_FEATURE_ALL, UK_FEATURE_RUSTLS,
UK_FEATURE_TONIC, UK_FEATURE_RING, UK_FEATURE_RUSTCRYPTO, UK_FEATURE_AWS_LC_RS)
to ensure literals remain in sync. Ensure references use the FeatureSet::new
entries and the BDD_FEATURE_MATRIX symbol so future edits are easy to locate.
- Around line 112-135: BDD_FEATURE_SETS is a manually maintained parallel list
that can drift from BDD_FEATURE_MATRIX and BDD_FEATURE_MATRIX also lacks a
uniqueness test; add a test that collects the names from BDD_FEATURE_MATRIX (by
iterating FeatureSet::name or equivalent accessor) and asserts they equal the
slice BDD_FEATURE_SETS (order and contents match), and add a test that asserts
all names in BDD_FEATURE_MATRIX are unique (similar to the existing
CORE_FEATURE_MATRIX uniqueness test) so the two cannot diverge or contain
duplicates; reference BDD_FEATURE_MATRIX, BDD_FEATURE_SETS, and the existing
CORE_FEATURE_MATRIX uniqueness test as the model for placement and behavior.

In `@crates/uselesskey-hmac/src/secret.rs`:
- Around line 71-73: Add a golden (snapshot) test that asserts the exact KID
string produced by kid_from_bytes/kid() for a fixed, hard-coded seed/secret
matches a stored expected value so future algorithm or parameter changes are
caught; create a new test (e.g., alongside kid_is_deterministic) that derives
secret_bytes from the same deterministic seed used in existing tests, calls
Secret::kid() or kid_from_bytes(secret_bytes()), and compares the result to an
explicit string literal (the golden value) instead of comparing two results from
the same algorithm.

In `@crates/uselesskey-x509/src/cert.rs`:
- Around line 598-654: Extract the repeated OID-find-and-parse logic into a test
helper (e.g. get_key_usage) and call it from test_leaf_cert_has_eku,
test_leaf_key_usage_bits, and test_ca_key_usage_bits to reduce boilerplate: the
helper should take cert_der: &[u8], parse with X509Certificate::from_der, locate
the extension matching OID_X509_EXT_KEY_USAGE, and return the
ParsedExtension::KeyUsage value (or panic on mismatch); be mindful of lifetimes
since KeyUsage borrows from the parsed certificate—either return an owned/cloned
KeyUsage or keep the parsed certificate in scope in the tests so the borrowed
KeyUsage remains valid.

In `@crates/uselesskey-x509/src/chain_spec.rs`:
- Around line 281-289: Add an isolated assertion that changing leaf_cn affects
stable_bytes: inside test_stable_bytes_field_sensitivity, clone base, call
.with_leaf_cn("other.example.com".to_string()) on the clone (similar to the
existing leaf_sans subcase), compute changed.stable_bytes() and
assert_ne!(changed.stable_bytes(), base_bytes, "leaf_cn must affect
stable_bytes"). This mirrors the SAN test and ensures leaf_cn's independent
contribution to stable_bytes is covered.

In `@crates/uselesskey-x509/src/spec.rs`:
- Around line 408-415: The test test_stable_bytes_field_sensitivity repeats the
same "clone → mutate one field → assert_ne" pattern for multiple fields;
refactor it to a parameterized rstest so each case is a separate test case with
its own name and failure message. Replace the monolithic assertions with an
rstest that takes parameters (a description/name, a closure or function that
given base returns the mutated object, and the expected inequality check) and
call changed.stable_bytes() vs base_bytes inside the parameterized test body;
reference the existing test name test_stable_bytes_field_sensitivity and the
methods used to mutate fields (e.g., with_subject, with_issuer, with_sans, etc.)
so you can swap each mutation into the rstest parameter list. Ensure you add the
rstest attribute and individual case names to produce targeted failures per
field.

---

Outside diff comments:
In `@crates/uselesskey-ecdsa/tests/jwk_private.rs`:
- Around line 90-103: The test kid_matches_public_key_hash_prefix hardcodes the
decoded KID length as 12; update it to use the shared constant
DEFAULT_KID_PREFIX_BYTES instead (use DEFAULT_KID_PREFIX_BYTES in the assertion
comparing decoded.len() to avoid the magic number) — if DEFAULT_KID_PREFIX_BYTES
is not pub from its crate, either make it public or import the value via the
crate's public API (or document why the test must keep a literal), and update
the assertion in the test function and any similar test (e.g., the counterpart
in the Ed25519 tests) to compare against DEFAULT_KID_PREFIX_BYTES rather than
12.

In `@crates/uselesskey-ed25519/tests/jwk_private.rs`:
- Around line 82-89: In the kid_matches_public_key_hash_prefix test (function
kid_matches_public_key_hash_prefix) replace the hard-coded literal 12 with the
exported constant DEFAULT_KID_PREFIX_BYTES from uselesskey_core_kid and add the
appropriate import; i.e., import DEFAULT_KID_PREFIX_BYTES from
uselesskey_core_kid and use it in the assert_eq!(decode_b64url(&kid).len(),
DEFAULT_KID_PREFIX_BYTES) assertion so the test uses the canonical constant
rather than a magic number.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@crates/uselesskey-core-negative/Cargo.toml`:
- Line 18: Replace the direct path/version dependency for uselesskey-core-id
with a workspace dependency for consistency: update the dependency entry for
"uselesskey-core-id" in the Cargo.toml from the current "{ path =
\"../uselesskey-core-id\", version = \"0.3.0\", default-features = false }" form
to use "workspace = true" (you can omit repeating default-features if the root
workspace already sets it) so version/workspace inheritance matches other
crates.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@crates/uselesskey-core-id/src/lib.rs`:
- Line 8: The function hash32 currently exposes blake3::Hash in the public API;
change hash32 to return a plain [u8; 32] instead of blake3::Hash (convert the
internal blake3 hash to a fixed-size array via .as_bytes() ->
try_into().unwrap() or equivalent), remove the public use/import of
blake3::Hash, and update all call sites (including tests referencing hash32 and
places that call .as_bytes() on its result) to accept the [u8; 32] return value
(dropping the extra .as_bytes() calls). Ensure any signatures or exports
referencing blake3::Hash (e.g., in docs or other public functions) are updated
to avoid leaking blake3 types.
- Around line 150-278: Add property-based tests using proptest in the existing
tests module to satisfy the guideline: write a proptest for idempotency that
generates arbitrary Seed (or [u8;32]) and ArtifactId and asserts
derive_seed(&master, &id).bytes() equals a second call; write an injectivity
proptest that generates a base ArtifactId then mutates exactly one field
(domain, label, variant, or DerivationVersion) via strategies and asserts
derive_seed results differ; and write a parse_hex_32 roundtrip proptest that
generates arbitrary [u8;32], hex-encodes it (with/without 0x and mixed
case/whitespace variants), calls parse_hex_32 and verifies the bytes match. Use
the existing symbols Seed, ArtifactId::new, derive_seed, parse_hex_32, and
DerivationVersion in the tests and add the proptest crate to dev-dependencies if
missing.

---

Duplicate comments:
In `@crates/uselesskey-core-id/src/lib.rs`:
- Around line 268-277: The two tests derive_seed_label_affects_output and
derive_seed_version_affects_output both repeat the same pattern; replace them
with a single parameterized rstest that takes variants (e.g., ("label",
"label-a", "label-b") and ("version", DerivationVersion::V1,
DerivationVersion::V2)) and asserts derive_seed(&master, &id1).bytes() !=
derive_seed(&master, &id2).bytes(); construct ArtifactId instances using
ArtifactId::new and Seed::new([5u8;32]) inside the fixture, add the #[rstest]
attribute and parameter list, and remove the duplicated standalone tests so the
behavior is covered by the single parameterized test using the derive_seed and
ArtifactId symbols.
- Around line 222-243: The test derive_seed_version_affects_output duplicates
version checks; convert it into a single parameterized rstest that iterates over
the DerivationVersion values (e.g., DerivationVersion::V1 and
DerivationVersion(2)) to avoid duplicated test bodies — keep usage of Seed::new,
ArtifactId::new, and derive_seed, and assert that derived bytes differ between
the two provided versions by comparing results from derive_seed for each version
pair; ensure the test function name and referenced symbols (derive_seed, Seed,
ArtifactId, DerivationVersion) remain so they are easy to locate.
- Around line 119-125: The library is printing to stderr with eprintln! in the
match arm (other => ...) which is not appropriate for a library; replace the
eprintln! call with a library-friendly logging call such as log::warn! (or
tracing::warn! if you use tracing) that includes the unknown derivation version
{other}, keep the fallback to derive_seed_v1(master, id) in that branch, and
ensure you add/enable the chosen logging crate (or gate the call behind an
optional feature) so the code compiles in your crate configuration; reference
the match arm containing derive_seed_v1 to locate the change.
- Around line 144-148: The write_len_prefixed function currently uses
u32::try_from(bytes.len()).unwrap_or(u32::MAX), which silently corrupts the
length prefix when the slice is larger than u32::MAX; change write_len_prefixed
to explicitly handle that overflow instead of defaulting to u32::MAX: perform
u32::try_from(bytes.len()) and propagate an error (change the signature to
return Result<(), E> and map the conversion failure into a clear error) or else
panic with a descriptive expect message (e.g.,
u32::try_from(...).expect("write_len_prefixed: input too large for u32 length
prefix")), and update any callers to handle the new Result if you choose the
error-return approach so no silent corruption can occur.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@crates/uselesskey-core-keypair/src/lib.rs`:
- Around line 133-139: The test debug_does_not_include_key_pem currently only
checks that the private PEM header is absent; update it to also assert that the
public-key PEM header is absent (e.g., check dbg does not contain "BEGIN PUBLIC
KEY") so the Debug output does not leak any key material from
Pkcs8SpkiKeyMaterial.
- Around line 70-77: The debug_does_not_include_key_pem test only checks that
"BEGIN PRIVATE KEY" is not present; update the test so it also asserts that
"BEGIN PUBLIC KEY" is absent to ensure neither private nor public key PEM
material is printed. Locate the test named debug_does_not_include_key_pem and
add an assertion that the debug string does not contain "BEGIN PUBLIC KEY" (in
addition to the existing "BEGIN PRIVATE KEY" check); you can reference the
key-producing methods write_private_key_pkcs8_pem and write_public_key_spki_pem
to ensure both PEM types are covered by the test.

---

Duplicate comments:
In `@crates/uselesskey-core-keypair/src/lib.rs`:
- Around line 110-117: Add gitleaks suppression annotations to the synthetic PEM
fixtures: insert a comment like "gitleaks:allow" immediately above the PEM
strings in sample_material() (the private/public key literals in
Pkcs8SpkiKeyMaterial::new) and likewise add the same "gitleaks:allow" comment
above the second fixture inside kid_depends_on_spki_bytes to suppress the
false-positive scanner hits on these fake PEM blocks.