[Question] Multi-phase workflow with working store and archive, how to update simple manifest properties? #176

Background
We are working on implemented C2PA support in Digital Asset Management (DAM) system, We are using c++ and the c2pa-c SDK.

What are we trying to do?
Using the c2pa::Builder, we are trying out a multi-phase workflow for building working stores for assets that live in our DAM system, and finally sign them when assets are downloaded or exported. The workflow is is similar to (or based on) what's described here under Two-phase workflow example in the working-stores doc.

OUR WORKFLOW

In phase 1

• create a Builder with an initial manifest
• add a parent-of ingredient
• add some action(s)
• call builder.to_archive(..) to save the working store for later

In n-number of phases

• restore the working store using Builder::from_archive(...)
• add some action(s) and maybe some component-of ingredients
• call builder.to_archive(..) to save the working store for later

In the final phase (the signing phase)

• restore the working store using Builder::from_archive(...)
• add some final action(s)
• [HERE IS THE ISSUE] update simple manifest properties before signing, e.g. title and format before signing.
• call builder.sign(...) to create a signed asset (usually requested by the user in form of an export or download on a specified format)

The workflow is working - except for the issue:

ISSUE
Our issue is in the "final phase". Before signing, we need to update some simple manifest properties. This can be title, format, application and version (in claim_generator_info). These are values that were not necessary known in "phase 1" when the working store was initially created. For example users may have re-titled the asset, and requested to convert and export it to a different format.

I have found no way using the c2pa-c SDK to do the update of the manifest properties as described above.

I see that in the node.js SDK, there seem to be a method that can be used for this, updateManifestProperty(property, value): void, but I found no equivalent in the C/C++ SDK.

My question is:

1. Is there maybe a (complete) different way to achieve what we are trying to do (that I haven't found)?
2. Is there currently lack of support for this in c2pa-c SDK that will/can be implemented later?

As a side comment, I would like to mention: each phase described above may happen on different system components (backends, desktop apps etc.). Archives (c2pa files) may be transferred across network boundaries. Also long time may pass between each phase.