lib

commit 2ba94e320150ff2e30ee3ca232fd665d8a29fb73
parent f8867cd6f4608933ae888f5c08f9befb459d3bdd
Author: triesap <tyson@radroots.org>
Date:   Mon, 27 Jul 2026 20:16:53 +0000

blossom: close exact readiness coverage

- exercise canonical media type URL and raster evidence failures
- prove oversized internal evidence serialization fails closed
- preserve WebP and JPEG validation behavior with measurable paths
- reach 100 percent across every governed Blossom coverage metric

Diffstat:
M
crates/blossom/src/publication_readiness.rs
 | 
45
++++++++++++++++++++++++++++++++++++++++-----
M
crates/blossom/src/publication_readiness/sequential_jpeg.rs
 | 
5
+++--
M
crates/blossom/tests/publication_readiness.rs
 | 
40
++++++++++++++++++++++++++++++++++++++++

3 files changed, 83 insertions(+), 7 deletions(-)
diff --git a/crates/blossom/src/publication_readiness.rs b/crates/blossom/src/publication_readiness.rs
@@ -595,11 +595,10 @@ fn decode_complete_webp(
     let dimensions = RadrootsBlossomRasterDimensions::new(width, height)?;
     require_matching_dimensions(dimensions, container_dimensions)?;
 
-    let decoded_bytes = bounded_decoded_byte_length(
-        u64::from(width)
-            .checked_mul(u64::from(height))
-            .and_then(|pixels| pixels.checked_mul(4)),
-    )?;
+    let decoded_length = u64::from(width)
+        .checked_mul(u64::from(height))
+        .and_then(|pixels| pixels.checked_mul(4));
+    let decoded_bytes = bounded_decoded_byte_length(decoded_length)?;
     let stride = width
         .checked_mul(4)
         .ok_or(RadrootsBlossomError::PublicationRasterDecodeFailed)?;
@@ -1615,6 +1614,42 @@ mod tests {
         );
     }
 
+    #[cfg(all(feature = "raster-decode", feature = "serde"))]
+    #[test]
+    fn readiness_evidence_serializer_rejects_oversized_internal_state() {
+        let expected = verified(PNG);
+        let (upload, head, get) = observations(PNG);
+        let mut evidence = verify_publication_readiness(
+            &expected,
+            PNG,
+            RadrootsBlossomAuthoredRasterDimensions::Unspecified,
+            &upload,
+            &head,
+            &get,
+        )
+        .unwrap();
+        let oversized_url = format!(
+            "https://cdn.example/{}.{}",
+            evidence.sha256(),
+            "p".repeat(RADROOTS_BLOSSOM_PUBLICATION_READINESS_EVIDENCE_MAX_BYTES),
+        );
+        evidence.url = RadrootsBlossomBlobUrl::parse(&oversized_url)
+            .unwrap()
+            .approve()
+            .unwrap();
+
+        match evidence.to_canonical_json().unwrap_err() {
+            RadrootsBlossomError::PublicationReadinessEvidenceTooLarge { max, actual } => {
+                assert_eq!(
+                    max,
+                    RADROOTS_BLOSSOM_PUBLICATION_READINESS_EVIDENCE_MAX_BYTES
+                );
+                assert!(actual > max);
+            }
+            error => panic!("unexpected evidence serialization error: {error}"),
+        }
+    }
+
     #[test]
     fn bounded_get_collector_rejects_status_bounds_and_body_shape() {
         let url = verified(PNG).url().clone();
diff --git a/crates/blossom/src/publication_readiness/sequential_jpeg.rs b/crates/blossom/src/publication_readiness/sequential_jpeg.rs
@@ -337,13 +337,14 @@ pub(super) fn validate(
                     .as_ref()
                     .ok_or(RadrootsBlossomError::PublicationRasterDecodeFailed)?;
                 let (payload, entropy_start) = strict_segment(bytes, after_marker)?;
-                let scan = parse_scan(
+                let scan_result = parse_scan(
                     payload,
                     current_frame,
                     &seen_components,
                     &dc_tables,
                     &ac_tables,
-                )?;
+                );
+                let scan = scan_result?;
                 position = validate_scan_entropy(
                     bytes,
                     entropy_start,
diff --git a/crates/blossom/tests/publication_readiness.rs b/crates/blossom/tests/publication_readiness.rs
@@ -174,11 +174,51 @@ fn publication_readiness_evidence_revalidates_every_persisted_fact() {
             "publication_readiness_evidence_field_invalid",
         ),
         (
+            "media_type",
+            serde_json::json!("not a media type"),
+            "publication_readiness_evidence_field_invalid",
+        ),
+        (
+            "media_type",
+            serde_json::json!("image/PNG"),
+            "publication_readiness_evidence_field_invalid",
+        ),
+        (
+            "media_type",
+            serde_json::json!("image/gif"),
+            "publication_readiness_evidence_field_invalid",
+        ),
+        (
             "raster_format",
             serde_json::json!("jpeg"),
             "publication_readiness_evidence_field_invalid",
         ),
         (
+            "raster_format",
+            serde_json::json!("still_webp"),
+            "publication_readiness_evidence_field_invalid",
+        ),
+        (
+            "raster_format",
+            serde_json::json!("unknown"),
+            "publication_readiness_evidence_field_invalid",
+        ),
+        (
+            "url",
+            serde_json::json!("not a URL"),
+            "publication_readiness_evidence_field_invalid",
+        ),
+        (
+            "url",
+            serde_json::json!(
+                evidence
+                    .url()
+                    .as_str()
+                    .replace("cdn.example", "CDN.example")
+            ),
+            "publication_readiness_evidence_field_invalid",
+        ),
+        (
             "bud02_status",
             serde_json::json!(202),
             "publication_readiness_evidence_field_invalid",