Merge branch 'main' into scouten/update-wasi-test-nightly

Author: scouten-adobe

.github/workflows/tier-1b.yml

@@ -160,7 +160,7 @@ jobs:
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: nightly-2025-07-28
+          toolchain: nightly-2025-12-06
 
       - name: Cache Rust dependencies
         uses: Swatinem/rust-cache@v2
@@ -169,7 +169,7 @@ jobs:
         env:
           FEATURES: ${{needs.get-features.outputs.openssl-features}}
         run: |
-          cargo +nightly-2025-07-28 test -Z direct-minimal-versions --all-targets --features "$FEATURES"
+          cargo +nightly-2025-12-06 test -Z direct-minimal-versions --all-targets --features "$FEATURES"
 
   docs_rs:
     name: Preflight docs.rs build
@@ -203,7 +203,7 @@ jobs:
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: nightly-2025-11-04
+          toolchain: nightly-2025-12-06
           # Pinning to specific nightly build for now. More recent versions
           # introduce a lifetime check that creates a whole slew of build
           # errors.

sdk/src/builder.rs

@@ -867,7 +867,6 @@ impl Builder {
             // we should be able to call Reader::from_stream and then convert to Builder
             // but we need to disable validation since we are not signing yet
             // so we will read the store directly here
-            //crate::Reader::from_stream("application/c2pa", stream).and_then(|r| r.into_builder())
             let settings = crate::settings::get_settings().unwrap_or_default();
             let mut http_resolver = RestrictedResolver::new(SyncGenericResolver::new());
             http_resolver.set_allowed_hosts(settings.core.allowed_network_hosts.clone());
@@ -1814,9 +1813,7 @@ impl Builder {
         let mut store = Store::new();
         store.commit_claim(claim)?;
 
-        //store.to_jumbf_internal(1000)
         store.get_data_hashed_manifest_placeholder(100, "application/c2pa")
-        //store.get_box_hashed_embeddable_manifest(signer.as_ref(), settings)
     }
 }
 

sdk/src/reader.rs

@@ -839,10 +839,65 @@ impl Reader {
         claim: &Claim,
         active_claim: &mut Claim,
     ) -> Result<()> {
+        let mut visited = std::collections::HashSet::new();
+        let mut path = Vec::new();
+        Self::collect_ingredient_claims_for_store_impl(
+            store,
+            claim,
+            active_claim,
+            &mut visited,
+            &mut path,
+        )
+    }
+
+    /// Uses the similar cycle detection strategy as Store::get_claim_referenced_manifests_impl
+    fn collect_ingredient_claims_for_store_impl(
+        store: &Store,
+        claim: &Claim,
+        active_claim: &mut Claim,
+        visited: &mut std::collections::HashSet<String>,
+        path: &mut Vec<String>,
+    ) -> Result<()> {
+        Self::collect_ingredient_claims_impl(store, claim, active_claim, visited, path)
+    }
+
+    /// Shared implementation for recursively collecting ingredient claims.
+    ///
+    /// Uses path-based cycle detection similar to Store::get_claim_referenced_manifests_impl:
+    /// - `visited`: Claims that have been fully processed (allows DAG convergence)
+    /// - `path`: Current traversal path to detect and skip cycles
+    fn collect_ingredient_claims_impl(
+        store: &Store,
+        claim: &Claim,
+        active_claim: &mut Claim,
+        visited: &mut std::collections::HashSet<String>,
+        path: &mut Vec<String>,
+    ) -> Result<()> {
+        let claim_label = claim.label();
+
+        if visited.contains(claim_label) {
+            return Ok(());
+        }
+
+        // Check for cycle: is this claim already in our current path?
+        // If so, skip it silently (validation should have already caught this when enabled)
+        if path.iter().any(|p| p == claim_label) {
+            return Ok(());
+        }
+
+        path.push(claim_label.to_string());
+
         for ingredient in claim.claim_ingredients() {
-            if let Some(ingredient_claim) = store.get_claim(ingredient.label()) {
-                // First, recursively collect any ingredients this claim references
-                Self::collect_ingredient_claims_for_store(store, ingredient_claim, active_claim)?;
+            let ingredient_label = ingredient.label();
+
+            if let Some(ingredient_claim) = store.get_claim(ingredient_label) {
+                Self::collect_ingredient_claims_impl(
+                    store,
+                    ingredient_claim,
+                    active_claim,
+                    visited,
+                    path,
+                )?;
 
                 // Then add this ingredient claim to the primary claim
                 active_claim.replace_ingredient_or_insert(
@@ -851,6 +906,13 @@ impl Reader {
                 );
             }
         }
+
+        // Mark as fully processed
+        visited.insert(claim_label.to_string());
+
+        // Remove from current path
+        path.pop();
+
         Ok(())
     }
 
@@ -997,16 +1059,31 @@ impl Reader {
                 builder.definition.instance_id = manifest.instance_id().to_owned();
                 builder.definition.thumbnail = manifest.thumbnail_ref().cloned();
                 builder.definition.redactions = manifest.redactions.take();
-                let ingredients = std::mem::take(&mut manifest.ingredients); //manifest.ingredients.drain(..).collect::<Vec<_>>();
+                let ingredients = std::mem::take(&mut manifest.ingredients);
                 for mut ingredient in ingredients {
                     if let Some(active_manifest) = ingredient.active_manifest() {
-                        let ingredient_claim = self.store.remove_claim(active_manifest);
+                        let ingredient_claim = self.store.get_claim(active_manifest);
                         if let Some(claim) = ingredient_claim {
                             // recreate an ingredient store to get the jumbf data
-                            let mut ingredient_store = Store::new();
-                            ingredient_store.commit_claim(claim.clone())?;
+                            // ... recursively collect all nested ingredient claims
+                            let ingredient_store = {
+                                let mut ingredient_store = Store::new();
+                                let mut active_claim = claim.clone();
+
+                                // Recursion happens here for claims collection - re-embed nested claims from store
+                                Self::collect_ingredient_claims_for_store(
+                                    &self.store,
+                                    claim,
+                                    &mut active_claim,
+                                )?;
+
+                                // Add the main claim with all nested ingredients
+                                ingredient_store.commit_claim(active_claim)?;
+                                ingredient_store
+                            };
                             let jumbf = ingredient_store.to_jumbf_internal(0)?;
-                            let manifest_data_ref = manifest.resources_mut().add_with(
+                            // Add manifest_data to the ingredient's own resources
+                            let manifest_data_ref = ingredient.resources_mut().add_with(
                                 "manifest_data",
                                 "application/c2pa",
                                 jumbf,
@@ -1059,7 +1136,14 @@ impl Reader {
                 let mut active_claim = claim.clone();
 
                 // Recursively collect all ingredient claims and add them to primary_claim
-                self.collect_ingredient_claims_recursive(claim, &mut active_claim)?;
+                let mut visited = std::collections::HashSet::new();
+                let mut path = Vec::new();
+                self.collect_ingredient_claims_recursive(
+                    claim,
+                    &mut active_claim,
+                    &mut visited,
+                    &mut path,
+                )?;
 
                 // Add the main claim last
                 store.commit_claim(active_claim)?;
@@ -1077,20 +1161,10 @@ impl Reader {
         &self,
         claim: &Claim,
         active_claim: &mut Claim,
+        visited: &mut std::collections::HashSet<String>,
+        path: &mut Vec<String>,
     ) -> Result<()> {
-        for ingredient in claim.claim_ingredients() {
-            if let Some(ingredient_claim) = self.store.get_claim(ingredient.label()) {
-                // First, recursively collect any ingredients this claim references
-                self.collect_ingredient_claims_recursive(ingredient_claim, active_claim)?;
-
-                // Then add this ingredient claim to the primary claim
-                active_claim.replace_ingredient_or_insert(
-                    ingredient_claim.label().to_string(),
-                    ingredient_claim.clone(),
-                );
-            }
-        }
-        Ok(())
+        Self::collect_ingredient_claims_impl(&self.store, claim, active_claim, visited, path)
     }
 }
 

sdk/src/store.rs

@@ -1541,6 +1541,63 @@ impl Store {
             store.insert_restored_claim(cai_store_desc_box.label(), claim);
         }
 
+        // Reconstruct nested claim relationships after all claims are loaded
+        // When claims are serialized, nested ingredients are extracted as top-level claims
+        // We need to restore them back into the parent claims' ingredient stores
+        use crate::assertions::Ingredient as IngredientAssertion;
+        let claim_labels: Vec<String> = store
+            .claims()
+            .iter()
+            .map(|c| c.label().to_string())
+            .collect();
+        for label in &claim_labels {
+            if let Some(claim) = store.get_claim(label) {
+                // Find ingredient assertions in this claim
+                let ingredient_refs: Vec<String> = claim
+                    .ingredient_assertions()
+                    .iter()
+                    .filter_map(|ing_assertion| {
+                        // Parse the ingredient assertion to get active_manifest or c2pa_manifest
+                        match IngredientAssertion::from_assertion(ing_assertion.assertion()) {
+                            Ok(ingredient) => {
+                                // Check both active_manifest (v3) and c2pa_manifest (v2)
+                                let hashed_uri = ingredient
+                                    .active_manifest
+                                    .as_ref()
+                                    .or(ingredient.c2pa_manifest.as_ref());
+
+                                if let Some(hashed_uri) = hashed_uri {
+                                    let url = hashed_uri.url();
+                                    // Extract the manifest label from the JUMBF URI
+                                    jumbf::labels::manifest_label_from_uri(&url)
+                                        .map(|l| l.to_string())
+                                } else {
+                                    None
+                                }
+                            }
+                            Err(_) => None,
+                        }
+                    })
+                    .collect();
+
+                if !ingredient_refs.is_empty() {
+                    // Clone the claim for modification
+                    let mut claim_mut = claim.clone();
+                    for ing_ref in &ingredient_refs {
+                        // Check if this referenced claim exists in the store
+                        if let Some(nested_claim) = store.get_claim(ing_ref) {
+                            claim_mut.replace_ingredient_or_insert(
+                                ing_ref.to_string(),
+                                nested_claim.clone(),
+                            );
+                        }
+                    }
+                    // Replace the claim in the store with the updated version
+                    store.claims_map.insert(label.to_string(), claim_mut);
+                }
+            }
+        }
+
         Ok(store)
     }
 
@@ -4194,8 +4251,9 @@ impl Store {
             final_redactions.append(&mut to_both);
         }
 
+        let claims_to_add: Vec<Claim> = i_store_mut.claims().into_iter().cloned().collect();
         claim.add_ingredient_data(
-            i_store_mut.claims().into_iter().cloned().collect(),
+            claims_to_add,
             Some(final_redactions),
             &svi.ingredient_references,
         )?;