lib

lib.rs (105707B)

---

 #![forbid(unsafe_code)]
 
 use radroots_blossom::{BlobDescriptor, BlobUrl, Error, MediaType, Sha256};
 use radroots_event::envelope::{EventEnvelope, EventEnvelopeError, EventEnvelopeParts};
 use radroots_event::farm::Farm;
 use radroots_event::farm::coop::Coop;
 use radroots_event::farm::crdt::FarmCrdtChange;
 use radroots_event::farm::file::FarmFileMetadata;
 use radroots_event::farm::plot::Plot;
 use radroots_event::farm::workspace::FarmWorkspaceManifest;
 use radroots_event::knowledge::{
     KnowledgeClaim, KnowledgeFieldReport, KnowledgeRelation, KnowledgeReview, KnowledgeSource,
     WikiArticle, WikiMergeRequest, WikiRedirect,
 };
 use radroots_event::listing::operational::OperationalListing;
 use radroots_event::media::file_metadata::FileMetadata;
 use radroots_event::media::{AuthoredImage, AuthoredImageError};
 use radroots_event::post::article::Article;
 use radroots_event::post::comment::{
     AuthoredNip22Comment, Nip22AddressRootReference, Nip22CommentError,
     Nip22CommentParentReference, Nip22CommentRoot, Nip22EventRootReference,
 };
 use radroots_event::post::document::Document;
 use radroots_event::post::reaction::Reaction;
 use radroots_event::post::report::Report;
 use radroots_event::post::repost::{GenericRepost, Repost};
 use radroots_event::post::{
     AuthoredAsk, AuthoredPhotoUpdate, AuthoredPostError, AuthoredPostImage, AuthoredUpdate,
     PostImageDimensions,
 };
 use radroots_event::social::follow::Follow;
 use radroots_event::social::gift_wrap::GiftWrap;
 use radroots_event::social::group::{
     GroupAdmins, GroupCreateGroup, GroupCreateInvite, GroupDeleteEvent, GroupDeleteGroup,
     GroupEditMetadata, GroupJoinRequest, GroupLeaveRequest, GroupMembers, GroupMetadata,
     GroupPutUser, GroupRemoveUser, GroupRoles,
 };
 use radroots_event::social::http_auth::HttpAuth;
 use radroots_event::social::job_feedback::JobFeedback;
 use radroots_event::social::job_request::JobRequest;
 use radroots_event::social::job_result::JobResult;
 use radroots_event::social::list::List;
 use radroots_event::social::list_set::ListSet;
 use radroots_event::social::message::Message;
 use radroots_event::social::message_file::MessageFile;
 use radroots_event::social::relay_auth::RelayAuth;
 use radroots_event::social::seal::Seal;
 use radroots_event::wire::Nip01EventWireParts;
 use radroots_event_codec::encode::article::article_build_tags;
 use radroots_event_codec::encode::comment::authored_nip22_comment_to_wire_parts;
 use radroots_event_codec::encode::coop::coop_build_tags;
 use radroots_event_codec::encode::document::document_build_tags;
 use radroots_event_codec::encode::farm::farm_build_tags;
 use radroots_event_codec::encode::farm_crdt::farm_crdt_change_build_tags_with_author;
 use radroots_event_codec::encode::farm_file::farm_file_metadata_build_tags;
 use radroots_event_codec::encode::farm_workspace::farm_workspace_build_tags;
 use radroots_event_codec::encode::file_metadata::file_metadata_build_tags;
 use radroots_event_codec::encode::follow::follow_build_tags;
 use radroots_event_codec::encode::gift_wrap::gift_wrap_build_tags;
 use radroots_event_codec::encode::group::{
     group_admins_build_tags, group_create_group_build_tags, group_create_invite_build_tags,
     group_delete_event_build_tags, group_delete_group_build_tags, group_edit_metadata_build_tags,
     group_join_request_build_tags, group_leave_request_build_tags, group_members_build_tags,
     group_metadata_build_tags, group_put_user_build_tags, group_remove_user_build_tags,
     group_roles_build_tags,
 };
 use radroots_event_codec::encode::http_auth::http_auth_build_tags;
 use radroots_event_codec::encode::job::feedback::job_feedback_build_tags;
 use radroots_event_codec::encode::job::request::job_request_build_tags;
 use radroots_event_codec::encode::job::result::job_result_build_tags;
 use radroots_event_codec::encode::knowledge::{
     knowledge_claim_build_tags, knowledge_field_report_build_tags, knowledge_relation_build_tags,
     knowledge_review_build_tags, knowledge_source_build_tags, wiki_article_build_tags,
     wiki_merge_request_build_tags, wiki_redirect_build_tags,
 };
 use radroots_event_codec::encode::list::list_build_tags;
 use radroots_event_codec::encode::list_set::list_set_build_tags;
 use radroots_event_codec::encode::message::message_build_tags;
 use radroots_event_codec::encode::message_file::message_file_build_tags;
 use radroots_event_codec::encode::operational_listing::{
     operational_listing_tags as operational_listing_tags_impl,
     operational_listing_tags_full as operational_listing_tags_full_impl,
 };
 use radroots_event_codec::encode::plot::plot_build_tags;
 use radroots_event_codec::encode::post::{
     authored_ask_to_wire_parts, authored_photo_update_to_wire_parts, authored_update_to_wire_parts,
 };
 use radroots_event_codec::encode::reaction::reaction_build_tags;
 use radroots_event_codec::encode::relay_auth::relay_auth_build_tags;
 use radroots_event_codec::encode::report::report_build_tags;
 use radroots_event_codec::encode::repost::{generic_repost_build_tags, repost_build_tags};
 use radroots_event_codec::encode::seal::seal_build_tags;
 use radroots_event_codec::verify::{RadrootsDecodeError, RadrootsDecodedEvent};
 use radroots_event_codec::{
     authoring::AuthoredEventPlan,
     decode::rhi::{
         RadrootsRhiEvidenceAttestationOutcomeV1, RadrootsRhiEvidenceAttestationV1,
         rhi_evidence_attestation_from_verified_event,
     },
     verify::{Nip01SignatureVerifier, id as verify_event_id, signature as verify_event_signature},
 };
 use radroots_trade::evidence::{
     RadrootsRhiEvidenceReportV1, RadrootsTradeEvidenceCoverageV1, RadrootsTradeEvidenceManifestV1,
     RadrootsTradeEvidenceOutcomeV1,
 };
 use serde::de::DeserializeOwned;
 use serde::{Deserialize, Serialize};
 #[cfg(target_arch = "wasm32")]
 use wasm_bindgen::JsValue;
 #[cfg(target_arch = "wasm32")]
 use wasm_bindgen::prelude::*;
 
 #[cfg(target_arch = "wasm32")]
 type RadrootsJsValue = JsValue;
 
 #[cfg(not(target_arch = "wasm32"))]
 type RadrootsJsValue = String;
 
 fn err_js<E: ToString>(err: E) -> RadrootsJsValue {
     #[cfg(target_arch = "wasm32")]
     {
         JsValue::from_str(&err.to_string())
     }
     #[cfg(not(target_arch = "wasm32"))]
     {
         err.to_string()
     }
 }
 
 fn error_json(code: &str, inner_code: Option<&str>) -> RadrootsJsValue {
     let value = serde_json::json!({
         "code": code,
         "inner_code": inner_code,
     });
     err_js(value)
 }
 
 fn normalized_payload(input: &str) -> &str {
     if input.is_empty() { "{}" } else { input }
 }
 
 fn parse_json<T: DeserializeOwned>(input: &str) -> Result<T, RadrootsJsValue> {
     serde_json::from_str(normalized_payload(input)).map_err(err_js)
 }
 
 fn parse_authored_json<T: DeserializeOwned>(input: &str) -> Result<T, RadrootsJsValue> {
     serde_json::from_str(input).map_err(|_| error_json("invalid_json", Some("authored_input")))
 }
 
 fn authored_error(code: &str) -> RadrootsJsValue {
     error_json("encode_error", Some(code))
 }
 
 fn blossom_authored_error(error: Error) -> RadrootsJsValue {
     authored_error(error.code())
 }
 
 fn post_authored_error(error: AuthoredPostError) -> RadrootsJsValue {
     authored_error(error.code())
 }
 
 fn image_authored_error(error: AuthoredImageError) -> RadrootsJsValue {
     authored_error(error.code())
 }
 
 fn comment_authored_error(error: Nip22CommentError) -> RadrootsJsValue {
     authored_error(error.code())
 }
 
 fn wire_parts_to_json(parts: &Nip01EventWireParts) -> Result<String, RadrootsJsValue> {
     serde_json::to_string(parts)
         .map_err(|_| error_json("internal_error", Some("wire_parts_serialization")))
 }
 
 fn tags_to_json(tags: Vec<Vec<String>>) -> Result<String, RadrootsJsValue> {
     serde_json::to_string(&tags).map_err(err_js)
 }
 
 #[derive(Serialize)]
 struct EvidenceManifestJson {
     contract_id: &'static str,
     contract_version: u16,
     trade_id: String,
     trade_generation: String,
     observed_at_unix_s: String,
     coverage: &'static str,
     evidence_policy_digest: String,
     manifest_digest: String,
     canonical_bytes_hex: String,
 }
 
 #[derive(Serialize)]
 struct EvidenceSupersessionJson {
     report_id: String,
     event_id: String,
 }
 
 #[derive(Serialize)]
 struct EvidenceReportJson {
     contract_id: &'static str,
     contract_version: u16,
     issuer_pubkey: String,
     trade_id: String,
     claim_mutation_id: String,
     outcome: &'static str,
     reason_codes: Vec<String>,
     projection_digest: String,
     evidence_manifest_digest: String,
     evidence_policy_digest: String,
     observed_at_unix_s: String,
     trade_generation: String,
     statement_digest: String,
     supersession: Option<EvidenceSupersessionJson>,
     canonical_content: String,
 }
 
 #[derive(Serialize)]
 struct TypedEvidenceEventPlanJson {
     contract_id: String,
     kind: u32,
     author_pubkey: String,
     created_at_unix_s: String,
     expected_event_id: String,
     tags: Vec<Vec<String>>,
     content: String,
 }
 
 #[derive(Serialize)]
 struct EvidenceAttestationJson {
     issuer_pubkey: String,
     trade_id: String,
     claim_mutation_id: String,
     outcome: &'static str,
     observed_at_unix_s: String,
     trade_generation: String,
     statement_digest: String,
     supersession: Option<EvidenceSupersessionJson>,
     canonical_content: String,
 }
 
 fn coverage_name(value: RadrootsTradeEvidenceCoverageV1) -> &'static str {
     match value {
         RadrootsTradeEvidenceCoverageV1::Missing => "missing",
         RadrootsTradeEvidenceCoverageV1::Partial => "partial",
         RadrootsTradeEvidenceCoverageV1::ScopeSatisfied => "scope_satisfied",
         RadrootsTradeEvidenceCoverageV1::Unsupported => "unsupported",
     }
 }
 
 fn outcome_name(value: RadrootsTradeEvidenceOutcomeV1) -> &'static str {
     match value {
         RadrootsTradeEvidenceOutcomeV1::Valid => "valid",
         RadrootsTradeEvidenceOutcomeV1::Invalid => "invalid",
         RadrootsTradeEvidenceOutcomeV1::Indeterminate => "indeterminate",
     }
 }
 
 fn attestation_outcome_name(value: RadrootsRhiEvidenceAttestationOutcomeV1) -> &'static str {
     match value {
         RadrootsRhiEvidenceAttestationOutcomeV1::Valid => "valid",
         RadrootsRhiEvidenceAttestationOutcomeV1::Invalid => "invalid",
         RadrootsRhiEvidenceAttestationOutcomeV1::Indeterminate => "indeterminate",
     }
 }
 
 fn evidence_report_json(value: &RadrootsRhiEvidenceReportV1) -> EvidenceReportJson {
     EvidenceReportJson {
         contract_id: value.contract_id(),
         contract_version: value.contract_version(),
         issuer_pubkey: value.issuer_public_key().to_hex(),
         trade_id: value.trade_id().to_string(),
         claim_mutation_id: value.claim_mutation_id().to_string(),
         outcome: outcome_name(value.outcome()),
         reason_codes: value
             .reason_codes()
             .iter()
             .map(|code| code.as_str().to_owned())
             .collect(),
         projection_digest: value.projection_digest().to_hex(),
         evidence_manifest_digest: value.evidence_manifest_digest().to_hex(),
         evidence_policy_digest: value.evidence_policy_digest().to_hex(),
         observed_at_unix_s: value.observed_at_unix_s().to_string(),
         trade_generation: value.trade_generation().get().to_string(),
         statement_digest: value.statement_digest().to_hex(),
         supersession: value
             .supersession()
             .map(|supersession| EvidenceSupersessionJson {
                 report_id: supersession.report_id().to_hex(),
                 event_id: supersession.event_id().to_hex(),
             }),
         canonical_content: value.canonical_content().to_owned(),
     }
 }
 
 fn typed_plan_json(value: &AuthoredEventPlan) -> TypedEvidenceEventPlanJson {
     TypedEvidenceEventPlanJson {
         contract_id: value.body().contract().contract_id().as_str().to_owned(),
         kind: value.body().kind(),
         author_pubkey: value.author().to_hex(),
         created_at_unix_s: value.created_at().to_string(),
         expected_event_id: value.expected_event_id().to_hex(),
         tags: value.body().tags().to_vec(),
         content: value.body().content().to_owned(),
     }
 }
 
 #[derive(Deserialize)]
 #[serde(deny_unknown_fields)]
 struct EventEnvelopeInput {
     id: String,
     author: String,
     created_at: u64,
     kind: u32,
     tags: Vec<Vec<String>>,
     content: String,
     sig: String,
 }
 
 fn envelope_error_code(error: &EventEnvelopeError) -> &'static str {
     match error {
         EventEnvelopeError::InvalidId(_) => "id_invalid",
         EventEnvelopeError::InvalidAuthor(_) => "author_invalid",
         EventEnvelopeError::InvalidSignature(_) => "signature_invalid",
         EventEnvelopeError::NonCanonicalId => "id_non_canonical",
         EventEnvelopeError::NonCanonicalAuthor => "author_non_canonical",
         EventEnvelopeError::NonCanonicalSignature => "signature_non_canonical",
         EventEnvelopeError::EmptyTag { .. } => "tag_empty",
         EventEnvelopeError::EmptyTagKey { .. } => "tag_key_empty",
         EventEnvelopeError::ControlCharacterTagKey { .. } => "tag_key_control_character",
         EventEnvelopeError::ContentTooLarge { .. } => "content_too_large",
         EventEnvelopeError::TooManyTags { .. } => "too_many_tags",
         EventEnvelopeError::TooManyTagElements { .. } => "too_many_tag_elements",
         EventEnvelopeError::TagElementTooLarge { .. } => "tag_element_too_large",
         EventEnvelopeError::TagsTooLarge { .. } => "tags_too_large",
     }
 }
 
 fn parse_event_json(input: &str) -> Result<EventEnvelope, RadrootsJsValue> {
     let envelope: EventEnvelopeInput =
         serde_json::from_str(input).map_err(|_| error_json("invalid_json", Some("event_json")))?;
     EventEnvelope::new(EventEnvelopeParts {
         id: envelope.id,
         author: envelope.author,
         created_at: envelope.created_at,
         kind: envelope.kind,
         tags: envelope.tags,
         content: envelope.content,
         sig: envelope.sig,
     })
     .map_err(|error| error_json("invalid_event", Some(envelope_error_code(&error))))
 }
 
 fn parse_bounded_event_json(input: &str) -> Result<EventEnvelope, RadrootsJsValue> {
     if input.len() > radroots_event::wire::v1::DEFAULT_RAW_JSON_MAX_BYTES {
         return Err(error_json("invalid_event", Some("event_too_large")));
     }
     parse_event_json(input)
 }
 
 fn build_tags_json<T, E, F>(input: &str, build: F) -> Result<String, RadrootsJsValue>
 where
     T: DeserializeOwned,
     E: ToString,
     F: FnOnce(&T) -> Result<Vec<Vec<String>>, E>,
 {
     let value = parse_json::<T>(input)?;
     let tags = build(&value).map_err(err_js)?;
     tags_to_json(tags)
 }
 
 fn build_tags_json_infallible<T, F>(input: &str, build: F) -> Result<String, RadrootsJsValue>
 where
     T: DeserializeOwned,
     F: FnOnce(&T) -> Vec<Vec<String>>,
 {
     let value = parse_json::<T>(input)?;
     let tags = build(&value);
     tags_to_json(tags)
 }
 
 #[derive(Serialize)]
 struct DecodedEventJson<'a, T>
 where
     T: Serialize,
 {
     event_type: &'static str,
     contract_id: &'static str,
     event: &'a radroots_event::envelope::EventEnvelope,
     payload: &'a T,
 }
 
 fn decoded_event_to_json(decoded: RadrootsDecodedEvent) -> Result<String, RadrootsJsValue> {
     match decoded {
         RadrootsDecodedEvent::WikiArticle(parsed) => {
             decoded_payload_to_json("wiki_article", "radroots.wiki.article.v1", &parsed)
         }
         RadrootsDecodedEvent::WikiRedirect(parsed) => {
             decoded_payload_to_json("wiki_redirect", "radroots.wiki.redirect.v1", &parsed)
         }
         RadrootsDecodedEvent::WikiMergeRequest(parsed) => decoded_payload_to_json(
             "wiki_merge_request",
             "radroots.wiki.merge_request.v1",
             &parsed,
         ),
         RadrootsDecodedEvent::KnowledgeSource(parsed) => {
             decoded_payload_to_json("knowledge_source", "radroots.knowledge.source.v1", &parsed)
         }
         RadrootsDecodedEvent::KnowledgeClaim(parsed) => {
             decoded_payload_to_json("knowledge_claim", "radroots.knowledge.claim.v1", &parsed)
         }
         RadrootsDecodedEvent::KnowledgeRelation(parsed) => decoded_payload_to_json(
             "knowledge_relation",
             "radroots.knowledge.relation.v1",
             &parsed,
         ),
         RadrootsDecodedEvent::KnowledgeReview(parsed) => {
             decoded_payload_to_json("knowledge_review", "radroots.knowledge.review.v1", &parsed)
         }
         RadrootsDecodedEvent::KnowledgeFieldReport(parsed) => decoded_payload_to_json(
             "knowledge_field_report",
             "radroots.knowledge.field_report.v1",
             &parsed,
         ),
         RadrootsDecodedEvent::EvidenceBounty(parsed) => decoded_payload_to_json(
             "evidence_bounty",
             "radroots.knowledge.evidence_bounty.v1",
             &parsed,
         ),
         RadrootsDecodedEvent::KnowledgeChangeProposal(parsed) => decoded_payload_to_json(
             "knowledge_change_proposal",
             "radroots.knowledge.change_proposal.v1",
             &parsed,
         ),
         RadrootsDecodedEvent::ContributionAttestation(parsed) => decoded_payload_to_json(
             "contribution_attestation",
             "radroots.knowledge.contribution_attestation.v1",
             &parsed,
         ),
     }
 }
 
 fn decoded_payload_to_json<T>(
     event_type: &'static str,
     contract_id: &'static str,
     parsed: &radroots_event_codec::decode::RadrootsParsedEvent<T>,
 ) -> Result<String, RadrootsJsValue>
 where
     T: Serialize,
 {
     serde_json::to_string(&DecodedEventJson {
         event_type,
         contract_id,
         event: &parsed.event,
         payload: &parsed.data.data,
     })
     .map_err(err_js)
 }
 
 fn decode_error_json(error: RadrootsDecodeError) -> RadrootsJsValue {
     let inner = match &error {
         RadrootsDecodeError::Nip01Verification(error) => Some(error.code()),
         RadrootsDecodeError::ContractValidation(error) => Some(error.code()),
         RadrootsDecodeError::EventParse(error) => Some(error.code()),
         RadrootsDecodeError::UnsupportedContract { .. } => None,
     };
     error_json(error.code(), inner)
 }
 
 #[derive(serde::Deserialize)]
 struct FarmCrdtTagsInput {
     change: FarmCrdtChange,
     author_pubkey: String,
 }
 
 #[derive(Deserialize)]
 #[serde(deny_unknown_fields)]
 struct AuthoredUpdateInput {
     content: String,
 }
 
 #[derive(Deserialize)]
 #[serde(deny_unknown_fields)]
 struct AuthoredMediaPostInput {
     content: String,
     #[serde(default)]
     images: Vec<AuthoredImageInput>,
 }
 
 #[derive(Deserialize)]
 #[serde(deny_unknown_fields)]
 struct AuthoredImageInput {
     bytes: Vec<u8>,
     url: String,
     media_type: String,
     uploaded: u64,
     width: u32,
     height: u32,
     alt: String,
     #[serde(default)]
     fallbacks: Vec<String>,
 }
 
 #[derive(Deserialize)]
 #[serde(deny_unknown_fields)]
 struct AuthoredCommentInput {
     content: String,
     root: AuthoredCommentRootInput,
     position: AuthoredCommentPositionInput,
 }
 
 #[derive(Deserialize)]
 #[serde(tag = "type", rename_all = "snake_case", deny_unknown_fields)]
 enum AuthoredCommentRootInput {
     Event {
         event_id: String,
         author: String,
         kind: u32,
         #[serde(default)]
         relay: Option<String>,
     },
     Address {
         coordinate: String,
         author: String,
         kind: u32,
         #[serde(default)]
         relay: Option<String>,
     },
 }
 
 #[derive(Deserialize)]
 #[serde(tag = "type", rename_all = "snake_case", deny_unknown_fields)]
 enum AuthoredCommentPositionInput {
     TopEvent,
     TopAddress { current_revision: String },
     Nested { parent: AuthoredCommentParentInput },
 }
 
 #[derive(Deserialize)]
 #[serde(deny_unknown_fields)]
 struct AuthoredCommentParentInput {
     event_id: String,
     author: String,
     #[serde(default)]
     relay: Option<String>,
 }
 
 fn authored_post_images(
     inputs: Vec<AuthoredImageInput>,
 ) -> Result<Vec<AuthoredPostImage>, RadrootsJsValue> {
     inputs.into_iter().map(authored_post_image).collect()
 }
 
 fn authored_post_image(input: AuthoredImageInput) -> Result<AuthoredPostImage, RadrootsJsValue> {
     let media_type = MediaType::parse(&input.media_type).map_err(blossom_authored_error)?;
     let sha256 = Sha256::digest(&input.bytes);
     let size = u64::try_from(input.bytes.len())
         .map_err(|_| authored_error("blob_size_platform_overflow"))?;
     let descriptor = BlobDescriptor::new(
         BlobUrl::parse(&input.url).map_err(blossom_authored_error)?,
         sha256,
         size,
         media_type.clone(),
         input.uploaded,
     )
     .map_err(blossom_authored_error)?
     .approve_reference()
     .map_err(blossom_authored_error)?
     .verify_bytes(&input.bytes, &media_type)
     .map_err(blossom_authored_error)?;
     let image =
         AuthoredImage::try_from_verified_descriptor(descriptor).map_err(image_authored_error)?;
     let dimensions =
         PostImageDimensions::new(input.width, input.height).map_err(post_authored_error)?;
     let mut authored =
         AuthoredPostImage::new(image, dimensions, input.alt).map_err(post_authored_error)?;
     for fallback in input.fallbacks {
         let fallback = BlobUrl::parse(&fallback)
             .map_err(blossom_authored_error)?
             .approve()
             .map_err(blossom_authored_error)?;
         authored = authored
             .try_with_fallback(fallback)
             .map_err(post_authored_error)?;
     }
     Ok(authored)
 }
 
 fn authored_comment_from_input(
     input: AuthoredCommentInput,
 ) -> Result<AuthoredNip22Comment, RadrootsJsValue> {
     let root = match input.root {
         AuthoredCommentRootInput::Event {
             event_id,
             author,
             kind,
             relay,
         } => Nip22CommentRoot::Event(
             Nip22EventRootReference::parse(event_id, author, kind, relay.as_deref())
                 .map_err(comment_authored_error)?,
         ),
         AuthoredCommentRootInput::Address {
             coordinate,
             author,
             kind,
             relay,
         } => {
             let root = Nip22AddressRootReference::parse(coordinate, relay.as_deref())
                 .map_err(comment_authored_error)?;
             if root.author().to_hex() != author {
                 return Err(authored_error("comment_root_author_mismatch"));
             }
             if root.kind().as_u32() != kind {
                 return Err(authored_error("comment_root_kind_mismatch"));
             }
             Nip22CommentRoot::Address(root)
         }
     };
 
     match (root, input.position) {
         (Nip22CommentRoot::Event(root), AuthoredCommentPositionInput::TopEvent) => {
             AuthoredNip22Comment::top_level_event(input.content, root)
                 .map_err(comment_authored_error)
         }
         (
             Nip22CommentRoot::Address(root),
             AuthoredCommentPositionInput::TopAddress { current_revision },
         ) => AuthoredNip22Comment::parse_top_level_address(input.content, root, current_revision)
             .map_err(comment_authored_error),
         (root, AuthoredCommentPositionInput::Nested { parent }) => {
             let parent = Nip22CommentParentReference::parse(
                 parent.event_id,
                 parent.author,
                 parent.relay.as_deref(),
             )
             .map_err(comment_authored_error)?;
             AuthoredNip22Comment::nested(input.content, root, parent)
                 .map_err(comment_authored_error)
         }
         _ => Err(authored_error("comment_root_position_incompatible")),
     }
 }
 
 /// Builds deterministic unsigned kind-1 wire parts for a strict Update.
 #[cfg_attr(
     target_arch = "wasm32",
     wasm_bindgen(js_name = social_update_build_authored_draft)
 )]
 pub fn social_update_build_authored_draft(input_json: &str) -> Result<String, RadrootsJsValue> {
     let input = parse_authored_json::<AuthoredUpdateInput>(input_json)?;
     let update = AuthoredUpdate::new(input.content).map_err(post_authored_error)?;
     wire_parts_to_json(&authored_update_to_wire_parts(&update))
 }
 
 /// Builds deterministic unsigned kind-1 wire parts for a strict PhotoUpdate.
 #[cfg_attr(
     target_arch = "wasm32",
     wasm_bindgen(js_name = social_photo_update_build_authored_draft)
 )]
 pub fn social_photo_update_build_authored_draft(
     input_json: &str,
 ) -> Result<String, RadrootsJsValue> {
     let input = parse_authored_json::<AuthoredMediaPostInput>(input_json)?;
     let images = authored_post_images(input.images)?;
     let photo = AuthoredPhotoUpdate::new(input.content, images).map_err(post_authored_error)?;
     wire_parts_to_json(&authored_photo_update_to_wire_parts(&photo))
 }
 
 /// Builds deterministic unsigned kind-1 wire parts for a strict Ask.
 #[cfg_attr(
     target_arch = "wasm32",
     wasm_bindgen(js_name = social_ask_build_authored_draft)
 )]
 pub fn social_ask_build_authored_draft(input_json: &str) -> Result<String, RadrootsJsValue> {
     let input = parse_authored_json::<AuthoredMediaPostInput>(input_json)?;
     let images = authored_post_images(input.images)?;
     let ask = AuthoredAsk::new(input.content, images).map_err(post_authored_error)?;
     wire_parts_to_json(&authored_ask_to_wire_parts(&ask))
 }
 
 /// Builds deterministic unsigned kind-1111 wire parts for a strict NIP-22 Comment.
 #[cfg_attr(
     target_arch = "wasm32",
     wasm_bindgen(js_name = social_comment_build_authored_draft)
 )]
 pub fn social_comment_build_authored_draft(input_json: &str) -> Result<String, RadrootsJsValue> {
     let input = parse_authored_json::<AuthoredCommentInput>(input_json)?;
     let comment = authored_comment_from_input(input)?;
     wire_parts_to_json(&authored_nip22_comment_to_wire_parts(&comment))
 }
 
 #[cfg_attr(
     target_arch = "wasm32",
     wasm_bindgen(js_name = operational_listing_tags)
 )]
 pub fn operational_listing_tags(listing_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<OperationalListing, _, _>(listing_json, operational_listing_tags_impl)
 }
 
 #[cfg_attr(
     target_arch = "wasm32",
     wasm_bindgen(js_name = operational_listing_tags_full)
 )]
 pub fn operational_listing_tags_full(listing_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<OperationalListing, _, _>(listing_json, operational_listing_tags_full_impl)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = article_tags))]
 pub fn article_tags(article_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<Article, _, _>(article_json, article_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = wiki_article_tags))]
 pub fn wiki_article_tags(article_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<WikiArticle, _, _>(article_json, wiki_article_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = wiki_redirect_tags))]
 pub fn wiki_redirect_tags(redirect_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<WikiRedirect, _, _>(redirect_json, wiki_redirect_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = wiki_merge_request_tags))]
 pub fn wiki_merge_request_tags(request_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<WikiMergeRequest, _, _>(request_json, wiki_merge_request_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = knowledge_source_tags))]
 pub fn knowledge_source_tags(source_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<KnowledgeSource, _, _>(source_json, knowledge_source_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = knowledge_claim_tags))]
 pub fn knowledge_claim_tags(claim_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<KnowledgeClaim, _, _>(claim_json, knowledge_claim_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = knowledge_relation_tags))]
 pub fn knowledge_relation_tags(relation_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<KnowledgeRelation, _, _>(relation_json, knowledge_relation_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = knowledge_review_tags))]
 pub fn knowledge_review_tags(review_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<KnowledgeReview, _, _>(review_json, knowledge_review_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = knowledge_field_report_tags))]
 pub fn knowledge_field_report_tags(report_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<KnowledgeFieldReport, _, _>(report_json, knowledge_field_report_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = verify_and_decode_event_json))]
 pub fn verify_and_decode_event_json(event_json: &str) -> Result<String, RadrootsJsValue> {
     let event = parse_event_json(event_json)?;
     let decoded = radroots_event_codec::verify::verify_and_decode_radroots_event(event)
         .map_err(decode_error_json)?;
     decoded_event_to_json(decoded)
 }
 
 /// Parses one bounded canonical evidence manifest supplied as lowercase hex.
 #[cfg_attr(
     target_arch = "wasm32",
     wasm_bindgen(js_name = trade_evidence_manifest_parse_json)
 )]
 pub fn trade_evidence_manifest_parse_json(
     canonical_bytes_hex: &str,
 ) -> Result<String, RadrootsJsValue> {
     if canonical_bytes_hex.len()
         > radroots_trade::evidence::RADROOTS_TRADE_EVIDENCE_MANIFEST_MAXIMUM_BYTES * 2
         || !canonical_bytes_hex.len().is_multiple_of(2)
         || !canonical_bytes_hex
             .bytes()
             .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
     {
         return Err(error_json("invalid_evidence_manifest", None));
     }
     let canonical_bytes = hex::decode(canonical_bytes_hex)
         .map_err(|_| error_json("invalid_evidence_manifest", None))?;
     let manifest = RadrootsTradeEvidenceManifestV1::from_canonical_bytes(&canonical_bytes)
         .map_err(|_| error_json("invalid_evidence_manifest", None))?;
     serde_json::to_string(&EvidenceManifestJson {
         contract_id: manifest.contract_id(),
         contract_version: manifest.contract_version(),
         trade_id: manifest.trade_id().to_string(),
         trade_generation: manifest.trade_generation().get().to_string(),
         observed_at_unix_s: manifest.observed_at_unix_s().to_string(),
         coverage: coverage_name(manifest.coverage()),
         evidence_policy_digest: manifest.evidence_policy_digest().to_hex(),
         manifest_digest: manifest.digest().to_hex(),
         canonical_bytes_hex: hex::encode(manifest.canonical_bytes()),
     })
     .map_err(|_| error_json("internal_error", Some("evidence_manifest_serialization")))
 }
 
 /// Parses one bounded canonical RHI evidence report.
 #[cfg_attr(
     target_arch = "wasm32",
     wasm_bindgen(js_name = rhi_evidence_report_parse_json)
 )]
 pub fn rhi_evidence_report_parse_json(canonical_content: &str) -> Result<String, RadrootsJsValue> {
     let report = RadrootsRhiEvidenceReportV1::from_canonical_content(canonical_content.as_bytes())
         .map_err(|_| error_json("invalid_evidence_report", None))?;
     serde_json::to_string(&evidence_report_json(&report))
         .map_err(|_| error_json("internal_error", Some("evidence_report_serialization")))
 }
 
 /// Builds one unsigned typed RHI evidence-attestation plan.
 #[cfg_attr(
     target_arch = "wasm32",
     wasm_bindgen(js_name = rhi_evidence_attestation_build_draft)
 )]
 pub fn rhi_evidence_attestation_build_draft(
     canonical_content: &str,
     created_at_unix_s: u64,
 ) -> Result<String, RadrootsJsValue> {
     let report = RadrootsRhiEvidenceReportV1::from_canonical_content(canonical_content.as_bytes())
         .map_err(|_| error_json("invalid_evidence_report", None))?;
     let attestation =
         RadrootsRhiEvidenceAttestationV1::from_canonical_content(report.canonical_content())
             .map_err(|_| error_json("invalid_evidence_attestation", None))?;
     let plan = AuthoredEventPlan::from_rhi_evidence_attestation(&attestation, created_at_unix_s)
         .map_err(|_| error_json("invalid_evidence_attestation_plan", None))?;
     serde_json::to_string(&typed_plan_json(&plan))
         .map_err(|_| error_json("internal_error", Some("evidence_plan_serialization")))
 }
 
 /// Verifies NIP-01 identity/signature before validating the RHI contract.
 #[cfg_attr(
     target_arch = "wasm32",
     wasm_bindgen(js_name = rhi_evidence_attestation_validate_signed_json)
 )]
 pub fn rhi_evidence_attestation_validate_signed_json(
     event_json: &str,
 ) -> Result<String, RadrootsJsValue> {
     let event = parse_bounded_event_json(event_json)?;
     let verified = verify_event_id(radroots_event::admission::RawEvent::new(event))
         .and_then(|event| verify_event_signature(event, &Nip01SignatureVerifier))
         .map_err(|_| error_json("invalid_event_signature", None))?;
     let attestation = rhi_evidence_attestation_from_verified_event(&verified)
         .map_err(|error| error_json("invalid_evidence_attestation", Some(error.code())))?;
     let supersession = attestation
         .supersession()
         .map(|supersession| EvidenceSupersessionJson {
             report_id: hex::encode(supersession.report_id()),
             event_id: supersession.event_id().to_hex(),
         });
     serde_json::to_string(&EvidenceAttestationJson {
         issuer_pubkey: attestation.issuer().to_hex(),
         trade_id: attestation.trade_id().to_string(),
         claim_mutation_id: attestation.claim_mutation_id().to_string(),
         outcome: attestation_outcome_name(attestation.outcome()),
         observed_at_unix_s: attestation.observed_at_unix_s().to_string(),
         trade_generation: attestation.trade_generation().get().to_string(),
         statement_digest: hex::encode(attestation.statement_digest()),
         supersession,
         canonical_content: attestation.canonical_content().to_owned(),
     })
     .map_err(|_| error_json("internal_error", Some("evidence_attestation_serialization")))
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = contract_manifest_json))]
 pub fn contract_manifest_json() -> Result<String, RadrootsJsValue> {
     radroots_event_codec::manifest::contract_manifest_json().map_err(err_js)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = file_metadata_tags))]
 pub fn file_metadata_tags(metadata_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<FileMetadata, _, _>(metadata_json, file_metadata_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = repost_tags))]
 pub fn repost_tags(repost_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<Repost, _, _>(repost_json, repost_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = generic_repost_tags))]
 pub fn generic_repost_tags(repost_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<GenericRepost, _, _>(repost_json, generic_repost_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = report_tags))]
 pub fn report_tags(report_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<Report, _, _>(report_json, report_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = follow_tags))]
 pub fn follow_tags(follow_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<Follow, _, _>(follow_json, follow_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = document_tags))]
 pub fn document_tags(document_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<Document, _, _>(document_json, document_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = coop_tags))]
 pub fn coop_tags(coop_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<Coop, _, _>(coop_json, coop_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = farm_tags))]
 pub fn farm_tags(farm_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<Farm, _, _>(farm_json, farm_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = list_tags))]
 pub fn list_tags(list_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<List, _, _>(list_json, list_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = list_set_tags))]
 pub fn list_set_tags(list_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<ListSet, _, _>(list_json, list_set_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = plot_tags))]
 pub fn plot_tags(plot_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<Plot, _, _>(plot_json, plot_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = job_request_tags))]
 pub fn job_request_tags(job_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json_infallible::<JobRequest, _>(job_json, job_request_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = job_result_tags))]
 pub fn job_result_tags(job_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json_infallible::<JobResult, _>(job_json, job_result_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = job_feedback_tags))]
 pub fn job_feedback_tags(job_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json_infallible::<JobFeedback, _>(job_json, job_feedback_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = reaction_tags))]
 pub fn reaction_tags(reaction_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<Reaction, _, _>(reaction_json, reaction_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = message_tags))]
 pub fn message_tags(message_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<Message, _, _>(message_json, message_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = message_file_tags))]
 pub fn message_file_tags(message_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<MessageFile, _, _>(message_json, message_file_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = seal_tags))]
 pub fn seal_tags(seal_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<Seal, _, _>(seal_json, seal_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = gift_wrap_tags))]
 pub fn gift_wrap_tags(gift_wrap_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<GiftWrap, _, _>(gift_wrap_json, gift_wrap_build_tags)
 }
 
 #[cfg_attr(
     target_arch = "wasm32",
     wasm_bindgen(js_name = farm_workspace_manifest_tags)
 )]
 pub fn farm_workspace_manifest_tags(workspace_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<FarmWorkspaceManifest, _, _>(workspace_json, farm_workspace_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = farm_crdt_change_tags))]
 pub fn farm_crdt_change_tags(input_json: &str) -> Result<String, RadrootsJsValue> {
     let input = parse_json::<FarmCrdtTagsInput>(input_json)?;
     let tags = farm_crdt_change_build_tags_with_author(&input.change, Some(&input.author_pubkey))
         .map_err(err_js)?;
     tags_to_json(tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = farm_file_metadata_tags))]
 pub fn farm_file_metadata_tags(file_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<FarmFileMetadata, _, _>(file_json, farm_file_metadata_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = relay_auth_tags))]
 pub fn relay_auth_tags(auth_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<RelayAuth, _, _>(auth_json, relay_auth_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = http_auth_tags))]
 pub fn http_auth_tags(auth_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<HttpAuth, _, _>(auth_json, http_auth_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = group_put_user_tags))]
 pub fn group_put_user_tags(group_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<GroupPutUser, _, _>(group_json, group_put_user_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = group_remove_user_tags))]
 pub fn group_remove_user_tags(group_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<GroupRemoveUser, _, _>(group_json, group_remove_user_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = group_create_group_tags))]
 pub fn group_create_group_tags(group_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<GroupCreateGroup, _, _>(group_json, group_create_group_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = group_edit_metadata_tags))]
 pub fn group_edit_metadata_tags(group_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<GroupEditMetadata, _, _>(group_json, group_edit_metadata_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = group_delete_group_tags))]
 pub fn group_delete_group_tags(group_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<GroupDeleteGroup, _, _>(group_json, group_delete_group_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = group_delete_event_tags))]
 pub fn group_delete_event_tags(group_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<GroupDeleteEvent, _, _>(group_json, group_delete_event_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = group_create_invite_tags))]
 pub fn group_create_invite_tags(group_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<GroupCreateInvite, _, _>(group_json, group_create_invite_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = group_join_request_tags))]
 pub fn group_join_request_tags(group_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<GroupJoinRequest, _, _>(group_json, group_join_request_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = group_leave_request_tags))]
 pub fn group_leave_request_tags(group_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<GroupLeaveRequest, _, _>(group_json, group_leave_request_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = group_metadata_tags))]
 pub fn group_metadata_tags(group_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<GroupMetadata, _, _>(group_json, group_metadata_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = group_admins_tags))]
 pub fn group_admins_tags(group_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<GroupAdmins, _, _>(group_json, group_admins_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = group_members_tags))]
 pub fn group_members_tags(group_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<GroupMembers, _, _>(group_json, group_members_build_tags)
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(js_name = group_roles_tags))]
 pub fn group_roles_tags(group_json: &str) -> Result<String, RadrootsJsValue> {
     build_tags_json::<GroupRoles, _, _>(group_json, group_roles_build_tags)
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use core::num::NonZeroU64;
     use radroots_core::{Currency, Decimal, Money, Quantity, QuantityPrice, Unit};
     use radroots_event::envelope::kind::{
         KIND_FARM_FILE_METADATA, KIND_FILE_METADATA, KIND_KNOWLEDGE_CLAIM, KIND_KNOWLEDGE_SOURCE,
         KIND_WIKI_ARTICLE,
     };
     use radroots_event::envelope::{EventEnvelope, EventEnvelopeLimits, EventEnvelopeParts};
     use radroots_event::farm::FarmRef;
     use radroots_event::farm::crdt::{
         CrdtBackend, FarmCrdtDocumentKind, FarmSemanticKind, RADROOTS_FARM_CRDT_CHANGE_SCHEMA,
     };
     use radroots_event::farm::file::{FarmFileDimensions, FarmFileMetadata, FarmFileSource};
     use radroots_event::farm::workspace::{
         FarmWorkspaceManifest, FarmWorkspaceMediaServer, FarmWorkspaceRef, FarmWorkspaceRelay,
         FarmWorkspaceRelayMode, RADROOTS_FARM_WORKSPACE_PROTOCOL_VERSION,
         RADROOTS_FARM_WORKSPACE_SCHEMA,
     };
     use radroots_event::id::TradeId;
     use radroots_event::knowledge::{
         AddressableRef, KnowledgeCitationSpan, KnowledgeFieldContext, KnowledgeLocation,
         KnowledgeLocationPrecision, KnowledgeNodeRef, KnowledgeObservation,
         KnowledgeObservationValue, KnowledgeReviewScope, KnowledgeReviewScore,
         KnowledgeReviewTarget, RADROOTS_KNOWLEDGE_CLAIM_SCHEMA,
         RADROOTS_KNOWLEDGE_FIELD_REPORT_SCHEMA, RADROOTS_KNOWLEDGE_RELATION_SCHEMA,
         RADROOTS_KNOWLEDGE_REVIEW_SCHEMA, RADROOTS_KNOWLEDGE_SCHEMA_VERSION,
         RADROOTS_KNOWLEDGE_SOURCE_SCHEMA, WikiArticleVersionRef,
     };
     use radroots_event::listing::operational::{OperationalListingBin, OperationalListingProduct};
     use radroots_event::social::group::{
         GroupAdmins, GroupCreateGroup, GroupCreateInvite, GroupDeleteEvent, GroupDeleteGroup,
         GroupEditMetadata, GroupEditableMetadata, GroupJoinRequest, GroupLeaveRequest,
         GroupMembers, GroupMetadata, GroupPutUser, GroupRemoveUser, GroupRole, GroupRoles,
         GroupUserRef,
     };
     use radroots_event::social::http_auth::HttpAuth;
     use radroots_event::social::job::JobInputType;
     use radroots_event::social::job_request::{JobInput, JobParam};
     use radroots_event::social::relay_auth::RelayAuth;
     use radroots_event::social::{
         ReportFileTarget, ReportType, SocialFarmAnchor, SocialLocation, SocialMediaDimensions,
         SocialTarget,
     };
     use radroots_trade::evidence::{
         RadrootsTradeEvidenceManifestSourceResultV1, RadrootsTradeEvidencePolicyDigestV1,
         RadrootsTradeEvidenceScopePrerequisitesV1, RadrootsTradeEvidenceSourceCompletionV1,
         RadrootsTradeEvidenceSourceIdV1, RadrootsTradeEvidenceSourceRequirementV1,
         RadrootsTradeEvidenceSourceResultDigestV1, RadrootsTradeEvidenceSourceResultV1,
     };
 
     fn sample_listing() -> OperationalListing {
         let quantity =
             Quantity::try_new(Decimal::from(1u32), Unit::Each).expect("positive fixture quantity");
         let price = QuantityPrice::try_new(
             Money::try_new(Decimal::from(10u32), Currency::USD)
                 .expect("non-negative fixture money"),
             quantity.clone(),
         )
         .expect("non-zero fixture pricing quantity");
 
         OperationalListing {
             d_tag: "AAAAAAAAAAAAAAAAAAAAAg".parse().expect("listing d tag"),
             published_at: None,
             farm: FarmRef {
                 pubkey: "farm_pubkey".to_string(),
                 d_tag: "AAAAAAAAAAAAAAAAAAAAAA".to_string(),
             },
             product: OperationalListingProduct {
                 key: "sku".to_string(),
                 title: "widget".to_string(),
                 category: "tools".to_string(),
                 summary: None,
                 process: None,
                 lot: None,
                 location: None,
                 profile: None,
                 year: None,
             },
             primary_bin_id: "bin-1".parse().expect("primary bin id"),
             bins: vec![OperationalListingBin {
                 bin_id: "bin-1".parse().expect("bin id"),
                 quantity,
                 price_per_canonical_unit: price,
                 display_amount: None,
                 display_unit: None,
                 display_label: None,
                 display_price: None,
                 display_price_unit: None,
             }],
             resource_area: None,
             plot: None,
             discounts: None,
             inventory_available: None,
             availability: None,
             delivery_method: None,
             location: None,
             images: None,
         }
     }
 
     fn synthetic_pubkey(seed: char) -> String {
         seed.to_string().repeat(64)
     }
 
     fn synthetic_event_id(seed: char) -> String {
         seed.to_string().repeat(64)
     }
 
     fn social_farm_anchor() -> SocialFarmAnchor {
         SocialFarmAnchor {
             farm: FarmRef {
                 pubkey: synthetic_pubkey('a'),
                 d_tag: "AAAAAAAAAAAAAAAAAAAAAA".to_string(),
             },
             relays: Some(vec!["wss://relay.example.test".to_string()]),
         }
     }
 
     fn event_target(kind: u32, seed: char) -> SocialTarget {
         SocialTarget::Event {
             id: synthetic_event_id(seed),
             author: Some(synthetic_pubkey('b')),
             event_kind: Some(kind),
             relays: Some(vec!["wss://relay.example.test".to_string()]),
         }
     }
 
     fn address_target(kind: u32, d_tag: &str) -> SocialTarget {
         let author = synthetic_pubkey('c');
         SocialTarget::Address {
             address: format!("{kind}:{author}:{d_tag}"),
             author: Some(author),
             event_kind: Some(kind),
             relays: Some(vec!["wss://relay2.example.test".to_string()]),
         }
     }
 
     fn knowledge_event_ref(seed: char, kind: u32) -> radroots_event::tag::EventRef {
         radroots_event::tag::EventRef {
             id: synthetic_event_id(seed),
             author: radroots_identity::PublicKey::from_hex(&synthetic_pubkey('a'))
                 .expect("fixture public key"),
             kind,
             d_tag: None,
             relays: Some(vec!["wss://relay.example.test".to_string()]),
         }
     }
 
     fn knowledge_address_ref() -> AddressableRef {
         AddressableRef {
             kind: KIND_WIKI_ARTICLE,
             pubkey: synthetic_pubkey('a'),
             d_tag: "soil-health".to_string(),
             relays: vec!["wss://relay.example.test".to_string()],
         }
     }
 
     fn sample_wiki_article() -> WikiArticle {
         WikiArticle {
             d_tag: "soil-health".to_string(),
             title: Some("Soil health".to_string()),
             content_djot: "# Soil health".to_string(),
             summary: Some("Living soil basics".to_string()),
             topics: vec!["soil".to_string()],
             references: vec![knowledge_event_ref('1', KIND_KNOWLEDGE_SOURCE)],
             forked_from: vec![WikiArticleVersionRef {
                 event_id: synthetic_event_id('b'),
                 address_ref: knowledge_address_ref(),
             }],
             deferred_to: None,
         }
     }
 
     fn sample_wiki_redirect() -> WikiRedirect {
         WikiRedirect {
             d_tag: "soil".to_string(),
             target: knowledge_address_ref(),
         }
     }
 
     fn sample_wiki_merge_request() -> WikiMergeRequest {
         WikiMergeRequest {
             target_article: knowledge_address_ref(),
             destination_pubkey: synthetic_pubkey('a'),
             base_version_event_id: Some(synthetic_event_id('e')),
             source_version_event_id: synthetic_event_id('f'),
             explanation: Some("Merge synthetic soil article updates".to_string()),
         }
     }
 
     fn sample_knowledge_source() -> KnowledgeSource {
         KnowledgeSource {
             schema: RADROOTS_KNOWLEDGE_SOURCE_SCHEMA.to_string(),
             schema_version: RADROOTS_KNOWLEDGE_SCHEMA_VERSION,
             d_tag: "soil-source".to_string(),
             title: "Soil Source".to_string(),
             source_type: "book".to_string(),
             authors: vec!["A. Example".to_string()],
             publisher: Some("Radroots Synthetic Press".to_string()),
             publication_year: Some(2026),
             edition: None,
             canonical_url: Some("https://source.example.test/soil-source".to_string()),
             artifact_refs: vec![knowledge_event_ref('3', KIND_FILE_METADATA)],
             author_asserted_rights: None,
             topics: vec!["soil".to_string()],
             summary: Some("Synthetic source for wasm coverage".to_string()),
         }
     }
 
     fn sample_knowledge_claim() -> KnowledgeClaim {
         KnowledgeClaim {
             schema: RADROOTS_KNOWLEDGE_CLAIM_SCHEMA.to_string(),
             schema_version: RADROOTS_KNOWLEDGE_SCHEMA_VERSION,
             claim_type: "practice_effect".to_string(),
             text: "Cover crops improve soil structure.".to_string(),
             citation_spans: vec![KnowledgeCitationSpan {
                 source_ref: knowledge_event_ref('4', KIND_KNOWLEDGE_SOURCE),
                 artifact_ref: None,
                 page_start: Some(12),
                 page_end: Some(13),
                 section_path: vec!["chapter-1".to_string()],
                 quote_hash: Some(synthetic_event_id('5')),
                 chunk_id: Some("chunk-1".to_string()),
             }],
             topics: vec!["cover-crops".to_string()],
             applies_to: vec!["local-food".to_string()],
             author_asserted_confidence: Some("medium".to_string()),
             supersedes: Vec::new(),
         }
     }
 
     fn sample_knowledge_node_ref(label: &str) -> KnowledgeNodeRef {
         KnowledgeNodeRef {
             node_type: "event".to_string(),
             event_ref: Some(knowledge_event_ref('6', KIND_KNOWLEDGE_CLAIM)),
             address_ref: None,
             external_id: None,
             label: Some(label.to_string()),
         }
     }
 
     fn sample_knowledge_relation() -> KnowledgeRelation {
         KnowledgeRelation {
             schema: RADROOTS_KNOWLEDGE_RELATION_SCHEMA.to_string(),
             schema_version: RADROOTS_KNOWLEDGE_SCHEMA_VERSION,
             subject: sample_knowledge_node_ref("cover crops"),
             predicate: "supports".to_string(),
             object: sample_knowledge_node_ref("soil structure"),
             support_refs: vec![knowledge_event_ref('7', KIND_KNOWLEDGE_CLAIM)],
             author_asserted_confidence: Some("medium".to_string()),
             supersedes: Vec::new(),
         }
     }
 
     fn sample_knowledge_review() -> KnowledgeReview {
         KnowledgeReview {
             schema: RADROOTS_KNOWLEDGE_REVIEW_SCHEMA.to_string(),
             schema_version: RADROOTS_KNOWLEDGE_SCHEMA_VERSION,
             target: KnowledgeReviewTarget {
                 event_id: synthetic_event_id('8'),
                 author_pubkey: synthetic_pubkey('a'),
                 kind: KIND_KNOWLEDGE_CLAIM,
                 address: None,
                 relays: vec!["wss://relay.example.test".to_string()],
                 review_scope: KnowledgeReviewScope::SpecificVersion,
             },
             reviewer_role: "peer".to_string(),
             verdict: "needs_more_evidence".to_string(),
             scores: vec![KnowledgeReviewScore {
                 dimension: "evidence".to_string(),
                 value: "partial".to_string(),
                 note: None,
             }],
             notes: Some("Synthetic review".to_string()),
             evidence_refs: vec![knowledge_event_ref('9', KIND_KNOWLEDGE_SOURCE)],
         }
     }
 
     fn sample_knowledge_field_report() -> KnowledgeFieldReport {
         KnowledgeFieldReport {
             schema: RADROOTS_KNOWLEDGE_FIELD_REPORT_SCHEMA.to_string(),
             schema_version: RADROOTS_KNOWLEDGE_SCHEMA_VERSION,
             report_type: "observation".to_string(),
             title: "Field observation".to_string(),
             summary: Some("Observed cover crop residue.".to_string()),
             context: KnowledgeFieldContext {
                 location_precision: KnowledgeLocationPrecision::CoarseGeohash,
                 public_location: Some(KnowledgeLocation {
                     label: Some("watershed".to_string()),
                     region: Some("synthetic-region".to_string()),
                     locality: None,
                     geohash: Some("c23".to_string()),
                 }),
                 private_location_ref: None,
                 topics: vec!["field".to_string()],
                 context_tags: vec!["observation".to_string()],
             },
             observations: vec![KnowledgeObservation {
                 observation_type: "residue".to_string(),
                 text: "Residue was visible across beds.".to_string(),
                 observed_at: Some("2026-07-05".to_string()),
                 values: vec![KnowledgeObservationValue {
                     key: "coverage".to_string(),
                     value: "medium".to_string(),
                     unit: None,
                 }],
             }],
             artifact_refs: vec![knowledge_event_ref('c', KIND_FILE_METADATA)],
             related_refs: vec![knowledge_event_ref('d', KIND_KNOWLEDGE_CLAIM)],
             limitations: vec!["single observer".to_string()],
         }
     }
 
     fn signed_claim_event_json() -> String {
         let claim_json = serde_json::to_string(&sample_knowledge_claim()).expect("claim json");
         let tags = serde_json::from_str::<Vec<Vec<String>>>(
             &knowledge_claim_tags(&claim_json).expect("claim tags"),
         )
         .expect("tags");
         let tags = tags
             .into_iter()
             .map(nostr::Tag::parse)
             .collect::<Result<Vec<_>, _>>()
             .expect("parsed tags");
         let keys = nostr::Keys::generate();
         let event =
             nostr::EventBuilder::new(nostr::Kind::Custom(KIND_KNOWLEDGE_CLAIM as u16), claim_json)
                 .tags(tags)
                 .custom_created_at(nostr::Timestamp::from_secs(1_800_000_000))
                 .sign_with_keys(&keys)
                 .expect("signed event");
         let envelope = EventEnvelope::new(EventEnvelopeParts {
             id: event.id.to_hex(),
             author: event.pubkey.to_hex(),
             created_at: event.created_at.as_secs(),
             kind: u32::from(event.kind.as_u16()),
             tags: event
                 .tags
                 .as_slice()
                 .iter()
                 .map(|tag| tag.as_slice().to_vec())
                 .collect(),
             content: event.content,
             sig: event.sig.to_string(),
         })
         .expect("event envelope");
         serde_json::to_string(&envelope).expect("event json")
     }
 
     fn social_location() -> SocialLocation {
         SocialLocation {
             name: Some("field edge".to_string()),
             geohash: Some("c23nb62w20st".to_string()),
         }
     }
 
     fn sample_article() -> Article {
         Article {
             d_tag: "AAAAAAAAAAAAAAAAAAAAAg".to_string(),
             title: "soil notes".to_string(),
             content: "# soil notes".to_string(),
             summary: Some("cover crop observations".to_string()),
             image: Some("https://media.example.test/article.jpg".to_string()),
             published_at: Some(1_780_000_000),
             farm: Some(social_farm_anchor()),
             location: Some(social_location()),
             topics: Some(vec!["soil".to_string(), "cover-crops".to_string()]),
         }
     }
 
     fn sample_public_file_metadata() -> FileMetadata {
         FileMetadata {
             url: "https://media.example.test/public.jpg".to_string(),
             mime_type: "image/jpeg".to_string(),
             sha256: "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef".to_string(),
             original_sha256: Some(
                 "abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789".to_string(),
             ),
             size: Some(4096),
             dimensions: Some(SocialMediaDimensions {
                 width: 1200,
                 height: 800,
             }),
             blurhash: None,
             thumbnails: None,
             summary: Some("public field photo".to_string()),
             alt: Some("rows after harvest".to_string()),
             fallback: Some("https://media.example.test/fallback.jpg".to_string()),
             magnet: Some("magnet:?xt=urn:btih:abc".to_string()),
             content_hashes: Some(vec!["sha256:field".to_string()]),
             services: Some(vec!["https://media.example.test".to_string()]),
             content: Some("caption".to_string()),
         }
     }
 
     fn sample_reaction() -> Reaction {
         Reaction {
             target: address_target(30023, "AAAAAAAAAAAAAAAAAAAAAg"),
             content: String::new(),
         }
     }
 
     fn sample_repost() -> Repost {
         Repost {
             target: event_target(1, 'b'),
             content: Some("field update".to_string()),
         }
     }
 
     fn sample_generic_repost() -> GenericRepost {
         GenericRepost {
             target: address_target(30023, "AAAAAAAAAAAAAAAAAAAAAg"),
             target_kind: 30023,
             content: Some("article share".to_string()),
         }
     }
 
     fn sample_report() -> Report {
         Report {
             reported_pubkey: synthetic_pubkey('b'),
             report_type: ReportType::Spam,
             event: Some(event_target(1, 'c')),
             file: Some(ReportFileTarget {
                 sha256: Some(
                     "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef".to_string(),
                 ),
                 url: Some("https://media.example.test/bad.jpg".to_string()),
                 magnet: None,
             }),
             content: Some("spam report".to_string()),
         }
     }
 
     fn sample_job_request() -> JobRequest {
         JobRequest {
             kind: 5100,
             inputs: vec![JobInput {
                 data: "alpha".to_string(),
                 input_type: JobInputType::Text,
                 relay: None,
                 marker: None,
             }],
             output: None,
             params: vec![JobParam {
                 key: "mode".to_string(),
                 value: "fast".to_string(),
             }],
             bid_sat: Some(42),
             relays: vec!["wss://relay.example.com".to_string()],
             providers: vec!["provider-a".to_string()],
             topics: vec!["topic-a".to_string()],
             encrypted: false,
         }
     }
 
     fn sample_workspace_manifest() -> FarmWorkspaceManifest {
         FarmWorkspaceManifest {
             d_tag: "AAAAAAAAAAAAAAAAAAAAAA".to_string(),
             schema: RADROOTS_FARM_WORKSPACE_SCHEMA.to_string(),
             farm_group_id: "field-group".to_string(),
             name: "Small Regen Farm".to_string(),
             owner_pubkey: "workspace_owner_pubkey".to_string(),
             farm: Some(FarmRef {
                 pubkey: "farm_pubkey".to_string(),
                 d_tag: "AAAAAAAAAAAAAAAAAAAAAQ".to_string(),
             }),
             relays: vec![FarmWorkspaceRelay {
                 url: "wss://relay.example.invalid/farm/field-group".to_string(),
                 mode: FarmWorkspaceRelayMode::ReadWrite,
             }],
             media_servers: vec![FarmWorkspaceMediaServer {
                 url: "https://media.example.invalid/farm/field-group".to_string(),
                 service: "RadrootsPrivateMedia".to_string(),
             }],
             supported_kinds: vec![78, 30078, KIND_FARM_FILE_METADATA],
             protocol_version: RADROOTS_FARM_WORKSPACE_PROTOCOL_VERSION.to_string(),
             created_at_ms: 1_780_000_000_000,
             updated_at_ms: None,
         }
     }
 
     fn sample_crdt_change() -> FarmCrdtChange {
         FarmCrdtChange {
             schema: RADROOTS_FARM_CRDT_CHANGE_SCHEMA.to_string(),
             workspace: FarmWorkspaceRef {
                 pubkey: "workspace_pubkey".to_string(),
                 d_tag: "AAAAAAAAAAAAAAAAAAAAAA".to_string(),
             },
             farm_group_id: "field-group".to_string(),
             document_id: "AAAAAAAAAAAAAAAAAAAAAg".to_string(),
             document_kind: FarmCrdtDocumentKind::FarmTask,
             crdt_backend: CrdtBackend::Automerge,
             crdt_backend_version: Some("0.x".to_string()),
             actor_id: "actor_abc".to_string(),
             change_hash: "crdt_hash_abc".to_string(),
             dependencies: Vec::new(),
             encoded_change: "abc-DEF_012".to_string(),
             semantic_kind: FarmSemanticKind::FarmTaskCreate,
             business_time_ms: 1_780_000_000_000,
             author_member_id: Some("member_abc".to_string()),
             app_version: Some("0.1.0".to_string()),
         }
     }
 
     fn sample_file_metadata() -> FarmFileMetadata {
         FarmFileMetadata {
             d_tag: "AAAAAAAAAAAAAAAAAAAAAQ".to_string(),
             workspace: FarmWorkspaceRef {
                 pubkey: "workspace_pubkey".to_string(),
                 d_tag: "AAAAAAAAAAAAAAAAAAAAAA".to_string(),
             },
             farm_group_id: "field-group".to_string(),
             owner_document_id: "AAAAAAAAAAAAAAAAAAAAAg".to_string(),
             owner_document_kind: FarmCrdtDocumentKind::FarmTask,
             caption: Some("Tomatoes harvested from Patch Y.".to_string()),
             url: "https://media.example.invalid/blob/sha256".to_string(),
             mime_type: "image/jpeg".to_string(),
             sha256: "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef".to_string(),
             original_sha256: None,
             size_bytes: Some(123_456),
             dimensions: Some(FarmFileDimensions { w: 1600, h: 1200 }),
             blurhash: None,
             thumb: Some(FarmFileSource {
                 url: "https://media.example.invalid/thumb/sha256".to_string(),
                 mime_type: Some("image/jpeg".to_string()),
                 dimensions: Some(FarmFileDimensions { w: 320, h: 240 }),
             }),
             image: None,
             alt: Some("Harvested tomatoes in a crate".to_string()),
             fallbacks: Vec::new(),
         }
     }
 
     fn sample_group_metadata() -> GroupEditableMetadata {
         GroupEditableMetadata {
             name: Some("Small Regen Farm".to_string()),
             about: Some("Field app group".to_string()),
             picture: Some("https://media.example.invalid/group.png".to_string()),
             is_private: false,
             is_restricted: true,
             is_closed: false,
             is_hidden: false,
             supported_kinds: Some(vec![78, 30078, KIND_FARM_FILE_METADATA]),
         }
     }
 
     fn sample_group_user(role: &str) -> GroupUserRef {
         GroupUserRef {
             pubkey: format!("{role}_pubkey"),
             roles: vec![role.to_string()],
         }
     }
 
     fn sample_group_role() -> GroupRole {
         GroupRole {
             name: "member".to_string(),
             description: Some("can read and write group events".to_string()),
             permissions: vec!["read".to_string(), "write".to_string()],
         }
     }
 
     fn assert_tags_json(value: Result<String, RadrootsJsValue>) {
         let tags = tags_json(value);
         assert!(!tags.is_empty());
     }
 
     fn tags_json(value: Result<String, RadrootsJsValue>) -> Vec<Vec<String>> {
         let json = value.expect("tags json");
         serde_json::from_str(&json).expect("tags")
     }
 
     fn has_tag(tags: &[Vec<String>], key: &str, value: &str) -> bool {
         tags.iter().any(|tag| {
             tag.first().map(|entry| entry.as_str()) == Some(key)
                 && tag.get(1).map(|entry| entry.as_str()) == Some(value)
         })
     }
 
     fn has_exact_tag(tags: &[Vec<String>], expected: &[&str]) -> bool {
         tags.iter().any(|tag| {
             tag.iter()
                 .map(|entry| entry.as_str())
                 .eq(expected.iter().copied())
         })
     }
 
     type BindingEncoder = fn(&str) -> Result<String, RadrootsJsValue>;
 
     const POST_AUTHORED_VECTORS: &str =
         include_str!("../../../contracts/conformance/vectors/post/verified_profiles.v1.json");
     const COMMENT_AUTHORED_VECTORS: &str =
         include_str!("../../../contracts/conformance/vectors/comment/verified_profile.v1.json");
 
     #[derive(Deserialize)]
     #[serde(deny_unknown_fields)]
     struct AuthoredVectorSuite {
         suite: String,
         contract_version: String,
         vectors: Vec<AuthoredVector>,
     }
 
     #[derive(Deserialize)]
     #[serde(deny_unknown_fields)]
     struct AuthoredVector {
         id: String,
         kind: String,
         input: serde_json::Value,
         expected: serde_json::Value,
     }
 
     fn authored_binding(kind: &str) -> Option<BindingEncoder> {
         if kind.starts_with("social.update.build_authored_draft.") {
             Some(social_update_build_authored_draft)
         } else if kind.starts_with("social.photo_update.build_authored_draft.") {
             Some(social_photo_update_build_authored_draft)
         } else if kind.starts_with("social.ask.build_authored_draft.") {
             Some(social_ask_build_authored_draft)
         } else if kind.starts_with("social.comment.build_authored_draft.") {
             Some(social_comment_build_authored_draft)
         } else {
             None
         }
     }
 
     fn authored_vector_request(vector: &AuthoredVector) -> String {
         let mut input = vector.input.clone();
         if let Some(images) = input
             .get_mut("images")
             .and_then(serde_json::Value::as_array_mut)
         {
             for image in images {
                 let image = image
                     .as_object_mut()
                     .unwrap_or_else(|| panic!("{} image must be an object", vector.id));
                 let bytes_utf8 = image
                     .remove("bytes_utf8")
                     .unwrap_or_else(|| panic!("{} image must carry vector bytes", vector.id));
                 let bytes_utf8 = bytes_utf8
                     .as_str()
                     .unwrap_or_else(|| panic!("{} vector bytes must be UTF-8 text", vector.id));
                 image.insert(
                     "bytes".to_owned(),
                     serde_json::Value::Array(
                         bytes_utf8
                             .as_bytes()
                             .iter()
                             .copied()
                             .map(serde_json::Value::from)
                             .collect(),
                     ),
                 );
             }
         }
         serde_json::to_string(&input)
             .unwrap_or_else(|error| panic!("{} request JSON failed: {error}", vector.id))
     }
 
     fn authored_error_value(error: RadrootsJsValue) -> serde_json::Value {
         serde_json::from_str(&error).expect("authored binding error must be coded JSON")
     }
 
     fn authored_error_inner(error: RadrootsJsValue) -> String {
         let error = authored_error_value(error);
         assert_eq!(error["code"], "encode_error");
         error["inner_code"]
             .as_str()
             .expect("authored error inner_code")
             .to_owned()
     }
 
     fn execute_authored_vectors(raw: &str, expected_suite: &str, expected_vector_count: usize) {
         let suite: AuthoredVectorSuite =
             serde_json::from_str(raw).expect("owner conformance vectors");
         assert_eq!(suite.suite, expected_suite);
         assert_eq!(suite.contract_version, "1.0.0");
         let mut executed = 0usize;
         for vector in suite.vectors {
             let Some(binding) = authored_binding(&vector.kind) else {
                 continue;
             };
             executed += 1;
             let request = authored_vector_request(&vector);
             if vector.kind.ends_with(".valid") {
                 let first = binding(&request)
                     .unwrap_or_else(|error| panic!("{} failed: {error}", vector.id));
                 let second = binding(&request)
                     .unwrap_or_else(|error| panic!("{} repeat failed: {error}", vector.id));
                 assert_eq!(first, second, "{} repeat encoding drifted", vector.id);
                 let actual: serde_json::Value = serde_json::from_str(&first)
                     .unwrap_or_else(|error| panic!("{} output JSON failed: {error}", vector.id));
                 assert_eq!(actual, vector.expected, "{}", vector.id);
             } else if vector.kind.ends_with(".invalid") {
                 let first = binding(&request).expect_err("invalid authored vector must fail");
                 let second =
                     binding(&request).expect_err("repeated invalid authored vector must fail");
                 let expected = vector.expected["error"]
                     .as_str()
                     .unwrap_or_else(|| panic!("{} expected error must be a string", vector.id));
                 assert_eq!(authored_error_inner(first), expected, "{}", vector.id);
                 assert_eq!(authored_error_inner(second), expected, "{}", vector.id);
             } else {
                 panic!("{} has unsupported authored vector kind", vector.id);
             }
         }
         assert_eq!(executed, expected_vector_count);
     }
 
     #[test]
     fn bindings_reject_invalid_json() {
         let bindings: [BindingEncoder; 44] = [
             social_update_build_authored_draft,
             social_photo_update_build_authored_draft,
             social_ask_build_authored_draft,
             social_comment_build_authored_draft,
             operational_listing_tags,
             operational_listing_tags_full,
             article_tags,
             file_metadata_tags,
             repost_tags,
             generic_repost_tags,
             report_tags,
             follow_tags,
             document_tags,
             coop_tags,
             farm_tags,
             list_tags,
             list_set_tags,
             plot_tags,
             job_request_tags,
             job_result_tags,
             job_feedback_tags,
             reaction_tags,
             message_tags,
             message_file_tags,
             seal_tags,
             gift_wrap_tags,
             farm_workspace_manifest_tags,
             farm_crdt_change_tags,
             farm_file_metadata_tags,
             relay_auth_tags,
             http_auth_tags,
             group_put_user_tags,
             group_remove_user_tags,
             group_create_group_tags,
             group_edit_metadata_tags,
             group_delete_group_tags,
             group_delete_event_tags,
             group_create_invite_tags,
             group_join_request_tags,
             group_leave_request_tags,
             group_metadata_tags,
             group_admins_tags,
             group_members_tags,
             group_roles_tags,
         ];
 
         for binding in bindings {
             assert!(binding("{").is_err());
         }
         assert!(operational_listing_tags("").is_err());
     }
 
     #[test]
     fn strict_authored_post_bindings_execute_owner_conformance_vectors() {
         execute_authored_vectors(POST_AUTHORED_VECTORS, "post_profiles", 6);
     }
 
     #[test]
     fn strict_authored_comment_binding_executes_owner_conformance_vectors() {
         execute_authored_vectors(COMMENT_AUTHORED_VECTORS, "nip22_comment_profile", 31);
     }
 
     #[test]
     fn authored_comment_rejects_address_coordinate_author_and_kind_mismatches() {
         let author = synthetic_pubkey('e');
         let coordinate = format!("30402:{author}:victoria-market");
         let request = |author: &str, kind: u32| {
             serde_json::json!({
                 "content": "Available this week",
                 "root": {
                     "type": "address",
                     "coordinate": coordinate,
                     "author": author,
                     "kind": kind,
                     "relay": null,
                 },
                 "position": {
                     "type": "top_address",
                     "current_revision": synthetic_event_id('b'),
                 },
             })
             .to_string()
         };
 
         let author_error =
             social_comment_build_authored_draft(&request(&synthetic_pubkey('f'), 30402))
                 .expect_err("coordinate author mismatch");
         assert_eq!(
             authored_error_inner(author_error),
             "comment_root_author_mismatch"
         );
 
         let kind_error = social_comment_build_authored_draft(&request(&author, 31922))
             .expect_err("coordinate kind mismatch");
         assert_eq!(
             authored_error_inner(kind_error),
             "comment_root_kind_mismatch"
         );
     }
 
     #[test]
     fn authored_image_errors_keep_the_stable_binding_code() {
         let error = image_authored_error(AuthoredImageError::MediaTypeNotImage);
         assert_eq!(authored_error_inner(error), "media_type_not_image");
     }
 
     #[test]
     fn authored_media_binding_verifies_exact_arbitrary_bytes() {
         let bytes = vec![0, 159, 146, 150];
         let hash = Sha256::digest(&bytes);
         let url = format!("https://media.example/{hash}.webp");
         let input = serde_json::json!({
             "content": format!("Harvest {url}"),
             "images": [{
                 "bytes": bytes,
                 "url": url,
                 "media_type": "image/webp",
                 "uploaded": 1_784_347_200_u64,
                 "width": 1200,
                 "height": 900,
                 "alt": "Harvest",
                 "fallbacks": [],
             }],
         });
 
         let encoded = social_photo_update_build_authored_draft(
             &serde_json::to_string(&input).expect("media request"),
         )
         .expect("byte-verified PhotoUpdate");
         let encoded: Nip01EventWireParts = serde_json::from_str(&encoded).expect("wire parts");
         assert_eq!(encoded.tags.len(), 1);
         assert!(encoded.tags[0].contains(&format!("x {hash}")));
         assert!(encoded.tags[0].contains(&"size 4".to_owned()));
 
         let mut wrong_bytes = input.clone();
         wrong_bytes["images"][0]["bytes"] = serde_json::json!([1, 2, 3, 4]);
         let error = social_photo_update_build_authored_draft(
             &serde_json::to_string(&wrong_bytes).expect("wrong-byte request"),
         )
         .expect_err("URL digest must bind exact bytes");
         assert_eq!(authored_error_inner(error), "descriptor_hash_mismatch");
     }
 
     #[test]
     fn authored_media_binding_rejects_fabricated_descriptor_fields() {
         let bytes = b"image".to_vec();
         let hash = Sha256::digest(&bytes);
         let url = format!("https://media.example/{hash}.webp");
         let mut input = serde_json::json!({
             "content": format!("Harvest {url}"),
             "images": [{
                 "bytes": bytes,
                 "url": url,
                 "media_type": "image/webp",
                 "uploaded": 1_784_347_200_u64,
                 "width": 1200,
                 "height": 900,
                 "alt": "Harvest",
             }],
         });
         input["images"][0]["sha256"] = serde_json::json!(hash.to_string());
         input["images"][0]["size"] = serde_json::json!(5);
 
         let error = social_photo_update_build_authored_draft(
             &serde_json::to_string(&input).expect("fabricated descriptor request"),
         )
         .expect_err("caller-supplied descriptor commitments must be rejected");
         let error = authored_error_value(error);
         assert_eq!(error["code"], "invalid_json");
         assert_eq!(error["inner_code"], "authored_input");
     }
 
     #[test]
     fn ask_allows_zero_media_while_photo_update_requires_media() {
         let ask = social_ask_build_authored_draft(r#"{"content":"When is harvest?","images":[]}"#)
             .expect("Ask without media");
         let ask: Nip01EventWireParts = serde_json::from_str(&ask).expect("Ask wire parts");
         assert_eq!(
             ask.tags,
             vec![vec!["t".to_owned(), "radroots-ask".to_owned()]]
         );
 
         let error =
             social_photo_update_build_authored_draft(r#"{"content":"Harvest","images":[]}"#)
                 .expect_err("PhotoUpdate without media");
         assert_eq!(authored_error_inner(error), "photo_imeta_missing");
     }
 
     #[test]
     fn bindings_encode_to_json_when_input_is_valid() {
         let listing_json = serde_json::to_string(&sample_listing()).expect("listing json");
         let listing_tags_json =
             operational_listing_tags(&listing_json).expect("operational listing tags");
         let listing_tags: Vec<Vec<String>> =
             serde_json::from_str(&listing_tags_json).expect("listing tags json");
         assert!(!listing_tags.is_empty());
 
         let request_json = serde_json::to_string(&sample_job_request()).expect("request json");
         let request_tags_json = job_request_tags(&request_json).expect("request tags");
         let request_tags: Vec<Vec<String>> =
             serde_json::from_str(&request_tags_json).expect("request tags json");
         assert!(!request_tags.is_empty());
     }
 
     #[test]
     fn social_bindings_encode_to_json_when_input_is_valid() {
         assert_tags_json(article_tags(
             &serde_json::to_string(&sample_article()).expect("article json"),
         ));
         assert_tags_json(file_metadata_tags(
             &serde_json::to_string(&sample_public_file_metadata()).expect("file json"),
         ));
         assert_tags_json(reaction_tags(
             &serde_json::to_string(&sample_reaction()).expect("reaction json"),
         ));
         assert_tags_json(repost_tags(
             &serde_json::to_string(&sample_repost()).expect("repost json"),
         ));
         assert_tags_json(generic_repost_tags(
             &serde_json::to_string(&sample_generic_repost()).expect("generic repost json"),
         ));
         assert_tags_json(report_tags(
             &serde_json::to_string(&sample_report()).expect("report json"),
         ));
     }
 
     #[test]
     fn social_bindings_surface_builder_errors() {
         let mut article = sample_article();
         article.d_tag.clear();
         assert!(article_tags(&serde_json::to_string(&article).expect("article json")).is_err());
 
         let mut reaction = sample_reaction();
         reaction.target = SocialTarget::External {
             id: "https://example.test/object".to_string(),
             external_kind: "web".to_string(),
             hint: None,
         };
         assert!(reaction_tags(&serde_json::to_string(&reaction).expect("reaction json")).is_err());
 
         let mut report = sample_report();
         report.reported_pubkey.clear();
         assert!(report_tags(&serde_json::to_string(&report).expect("report json")).is_err());
     }
 
     #[test]
     fn knowledge_bindings_encode_to_json_when_input_is_valid() {
         let article_tags = tags_json(wiki_article_tags(
             &serde_json::to_string(&sample_wiki_article()).expect("wiki article json"),
         ));
         assert!(has_tag(&article_tags, "title", "Soil health"));
         let fork_address = format!(
             "{}:{}:soil-health",
             KIND_WIKI_ARTICLE,
             synthetic_pubkey('a')
         );
         let fork_event_id = synthetic_event_id('b');
         assert!(has_exact_tag(
             &article_tags,
             &[
                 "a",
                 fork_address.as_str(),
                 "wss://relay.example.test",
                 "fork"
             ]
         ));
         assert!(has_exact_tag(
             &article_tags,
             &[
                 "e",
                 fork_event_id.as_str(),
                 "wss://relay.example.test",
                 "fork"
             ]
         ));
 
         let redirect_tags = tags_json(wiki_redirect_tags(
             &serde_json::to_string(&sample_wiki_redirect()).expect("wiki redirect json"),
         ));
         let redirect_address = format!(
             "{}:{}:soil-health",
             KIND_WIKI_ARTICLE,
             synthetic_pubkey('a')
         );
         assert!(has_exact_tag(
             &redirect_tags,
             &["a", redirect_address.as_str(), "wss://relay.example.test"]
         ));
 
         let merge_request = sample_wiki_merge_request();
         let merge_parts =
             radroots_event_codec::encode::knowledge::wiki_merge_request_to_wire_parts(
                 &merge_request,
             )
             .expect("merge request parts");
         assert_eq!(merge_parts.content, "Merge synthetic soil article updates");
         let merge_tags = tags_json(wiki_merge_request_tags(
             &serde_json::to_string(&sample_wiki_merge_request()).expect("merge request json"),
         ));
         let source_event_id = synthetic_event_id('f');
         assert!(has_exact_tag(
             &merge_tags,
             &["e", source_event_id.as_str(), "", "source"]
         ));
 
         let source_tags = tags_json(knowledge_source_tags(
             &serde_json::to_string(&sample_knowledge_source()).expect("source json"),
         ));
         assert!(has_tag(
             &source_tags,
             "contract",
             RADROOTS_KNOWLEDGE_SOURCE_SCHEMA
         ));
 
         let claim_tags = tags_json(knowledge_claim_tags(
             &serde_json::to_string(&sample_knowledge_claim()).expect("claim json"),
         ));
         assert!(has_tag(
             &claim_tags,
             "contract",
             RADROOTS_KNOWLEDGE_CLAIM_SCHEMA
         ));
 
         assert_tags_json(knowledge_relation_tags(
             &serde_json::to_string(&sample_knowledge_relation()).expect("relation json"),
         ));
         assert_tags_json(knowledge_review_tags(
             &serde_json::to_string(&sample_knowledge_review()).expect("review json"),
         ));
         assert_tags_json(knowledge_field_report_tags(
             &serde_json::to_string(&sample_knowledge_field_report()).expect("field report json"),
         ));
     }
 
     #[test]
     fn wiki_article_tags_accept_missing_title() {
         let mut article = sample_wiki_article();
         article.title = None;
         let tags = tags_json(wiki_article_tags(
             &serde_json::to_string(&article).expect("wiki article json"),
         ));
         assert!(
             !tags
                 .iter()
                 .any(|tag| tag.first().map(String::as_str) == Some("title"))
         );
     }
 
     #[test]
     fn knowledge_claim_tags_enforce_citation_rules() {
         let mut claim = sample_knowledge_claim();
         claim.citation_spans.clear();
         let error = knowledge_claim_tags(
             &serde_json::to_string(&claim).expect("uncited source-backed claim json"),
         )
         .expect_err("source-backed claim requires citations");
         assert!(error.contains("citation_spans"));
 
         assert_tags_json(knowledge_claim_tags(
             &serde_json::to_string(&sample_knowledge_claim()).expect("claim json"),
         ));
 
         for claim_type in ["hypothesis", "observation", "question"] {
             let mut uncited = sample_knowledge_claim();
             uncited.claim_type = claim_type.to_string();
             uncited.citation_spans.clear();
             assert_tags_json(knowledge_claim_tags(
                 &serde_json::to_string(&uncited).expect("uncited claim json"),
             ));
         }
     }
 
     #[test]
     fn knowledge_bindings_verify_decode_and_manifest_json() {
         let decoded = verify_and_decode_event_json(&signed_claim_event_json()).expect("decoded");
         let decoded: serde_json::Value = serde_json::from_str(&decoded).expect("decoded json");
         assert_eq!(decoded["event_type"], "knowledge_claim");
         assert_eq!(decoded["contract_id"], RADROOTS_KNOWLEDGE_CLAIM_SCHEMA);
         assert_eq!(
             decoded["payload"]["text"],
             "Cover crops improve soil structure."
         );
 
         let manifest = contract_manifest_json().expect("manifest");
         let manifest: serde_json::Value = serde_json::from_str(&manifest).expect("manifest json");
         assert_eq!(manifest["schema_version"], 2);
         assert_eq!(manifest["contract_count"], 11);
         let claim_contract = manifest["contracts"]
             .as_array()
             .expect("contracts")
             .iter()
             .find(|contract| contract["contract_id"] == RADROOTS_KNOWLEDGE_CLAIM_SCHEMA)
             .expect("claim contract");
         assert_eq!(claim_contract["sdk_builder_support"], true);
         assert_eq!(claim_contract["sdk_draft_support"], true);
         assert_eq!(claim_contract["wasm_tag_builder_support"], true);
         assert_eq!(claim_contract["wasm_verified_decode_support"], true);
     }
 
     #[test]
     fn knowledge_bindings_verify_decode_errors_are_coded_json() {
         let invalid_json = verify_and_decode_event_json("not json").expect_err("invalid json");
         let invalid_json: serde_json::Value =
             serde_json::from_str(&invalid_json).expect("error json");
         assert_eq!(invalid_json["code"], "invalid_json");
         assert_eq!(invalid_json["inner_code"], "event_json");
 
         let mut event: serde_json::Value =
             serde_json::from_str(&signed_claim_event_json()).expect("event json");
         event["sig"] = serde_json::Value::String("0".repeat(128));
         let signature_error =
             verify_and_decode_event_json(&event.to_string()).expect_err("signature error");
         let signature_error: serde_json::Value =
             serde_json::from_str(&signature_error).expect("signature error json");
         assert_eq!(signature_error["code"], "nip01_verification");
         assert_eq!(signature_error["inner_code"], "signature_invalid");
     }
 
     #[test]
     fn knowledge_bindings_reject_unchecked_event_envelope_input() {
         let mut oversized: serde_json::Value =
             serde_json::from_str(&signed_claim_event_json()).expect("event json");
         oversized["content"] = serde_json::Value::String(
             "x".repeat(EventEnvelopeLimits::default().max_content_bytes + 1),
         );
         let oversized_error =
             verify_and_decode_event_json(&oversized.to_string()).expect_err("oversized content");
         let oversized_error: serde_json::Value =
             serde_json::from_str(&oversized_error).expect("oversized error json");
         assert_eq!(oversized_error["code"], "invalid_event");
         assert_eq!(oversized_error["inner_code"], "content_too_large");
 
         let mut non_canonical: serde_json::Value =
             serde_json::from_str(&signed_claim_event_json()).expect("event json");
         non_canonical["id"] = serde_json::Value::String("A".repeat(64));
         let canonical_error =
             verify_and_decode_event_json(&non_canonical.to_string()).expect_err("non-canonical id");
         let canonical_error: serde_json::Value =
             serde_json::from_str(&canonical_error).expect("canonical error json");
         assert_eq!(canonical_error["code"], "invalid_event");
         assert_eq!(canonical_error["inner_code"], "id_non_canonical");
 
         let mut unknown_field: serde_json::Value =
             serde_json::from_str(&signed_claim_event_json()).expect("event json");
         unknown_field["verified"] = serde_json::Value::Bool(true);
         let unknown_error = verify_and_decode_event_json(&unknown_field.to_string())
             .expect_err("unknown event field");
         let unknown_error: serde_json::Value =
             serde_json::from_str(&unknown_error).expect("unknown-field error json");
         assert_eq!(unknown_error["code"], "invalid_json");
         assert_eq!(unknown_error["inner_code"], "event_json");
     }
 
     #[test]
     fn event_envelope_error_codes_cover_every_structural_limit_class() {
         let cases = [
             (
                 EventEnvelopeError::NonCanonicalAuthor,
                 "author_non_canonical",
             ),
             (
                 EventEnvelopeError::NonCanonicalSignature,
                 "signature_non_canonical",
             ),
             (EventEnvelopeError::EmptyTag { index: 0 }, "tag_empty"),
             (
                 EventEnvelopeError::EmptyTagKey { index: 0 },
                 "tag_key_empty",
             ),
             (
                 EventEnvelopeError::ControlCharacterTagKey { index: 0 },
                 "tag_key_control_character",
             ),
             (
                 EventEnvelopeError::TooManyTags { max: 1, actual: 2 },
                 "too_many_tags",
             ),
             (
                 EventEnvelopeError::TooManyTagElements { max: 1, actual: 2 },
                 "too_many_tag_elements",
             ),
             (
                 EventEnvelopeError::TagElementTooLarge {
                     tag_index: 0,
                     element_index: 0,
                     max: 1,
                     actual: 2,
                 },
                 "tag_element_too_large",
             ),
             (
                 EventEnvelopeError::TagsTooLarge { max: 1, actual: 2 },
                 "tags_too_large",
             ),
         ];
         for (error, code) in cases {
             assert_eq!(envelope_error_code(&error), code);
         }
     }
 
     #[test]
     fn field_bindings_encode_to_json_when_input_is_valid() {
         let workspace_json =
             serde_json::to_string(&sample_workspace_manifest()).expect("workspace json");
         assert_tags_json(farm_workspace_manifest_tags(&workspace_json));
 
         let crdt_json = serde_json::json!({
             "change": sample_crdt_change(),
             "author_pubkey": "author_pubkey"
         })
         .to_string();
         assert_tags_json(farm_crdt_change_tags(&crdt_json));
 
         let file_json = serde_json::to_string(&sample_file_metadata()).expect("file json");
         assert_tags_json(farm_file_metadata_tags(&file_json));
 
         let relay_auth_json = serde_json::to_string(&RelayAuth {
             relay: "wss://relay.example.invalid/farm/field-group".to_string(),
             challenge: "relay-provided-challenge".to_string(),
         })
         .expect("relay auth json");
         assert_tags_json(relay_auth_tags(&relay_auth_json));
 
         let http_auth_json = serde_json::to_string(&HttpAuth {
             url: "https://media.example.invalid/upload".to_string(),
             method: "POST".to_string(),
             payload_sha256: Some(
                 "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef".to_string(),
             ),
         })
         .expect("http auth json");
         assert_tags_json(http_auth_tags(&http_auth_json));
     }
 
     #[test]
     fn field_bindings_surface_builder_errors() {
         let crdt_json = serde_json::json!({
             "change": sample_crdt_change(),
             "author_pubkey": " "
         })
         .to_string();
 
         assert!(farm_crdt_change_tags(&crdt_json).is_err());
     }
 
     #[test]
     fn group_bindings_encode_to_json_when_input_is_valid() {
         let metadata = sample_group_metadata();
         assert_tags_json(group_put_user_tags(
             &serde_json::to_string(&GroupPutUser {
                 group_id: "field-group".to_string(),
                 message: Some("add member".to_string()),
                 pubkey: "member_pubkey".to_string(),
                 roles: vec!["member".to_string()],
             })
             .expect("put user json"),
         ));
         assert_tags_json(group_remove_user_tags(
             &serde_json::to_string(&GroupRemoveUser {
                 group_id: "field-group".to_string(),
                 message: Some("remove member".to_string()),
                 pubkey: "member_pubkey".to_string(),
             })
             .expect("remove user json"),
         ));
         assert_tags_json(group_create_group_tags(
             &serde_json::to_string(&GroupCreateGroup {
                 group_id: "field-group".to_string(),
                 message: Some("create group".to_string()),
                 metadata: metadata.clone(),
             })
             .expect("create group json"),
         ));
         assert_tags_json(group_edit_metadata_tags(
             &serde_json::to_string(&GroupEditMetadata {
                 group_id: "field-group".to_string(),
                 message: Some("edit metadata".to_string()),
                 metadata: metadata.clone(),
             })
             .expect("edit metadata json"),
         ));
         assert_tags_json(group_delete_group_tags(
             &serde_json::to_string(&GroupDeleteGroup {
                 group_id: "field-group".to_string(),
                 message: Some("delete group".to_string()),
             })
             .expect("delete group json"),
         ));
         assert_tags_json(group_delete_event_tags(
             &serde_json::to_string(&GroupDeleteEvent {
                 group_id: "field-group".to_string(),
                 message: Some("delete event".to_string()),
                 event_id: "event_id".to_string(),
             })
             .expect("delete event json"),
         ));
         let invite_tags = tags_json(group_create_invite_tags(
             &serde_json::to_string(&GroupCreateInvite {
                 group_id: "field-group".to_string(),
                 message: Some("join the field group".to_string()),
                 code: "invite-code".to_string(),
             })
             .expect("invite json"),
         ));
         assert!(invite_tags.contains(&vec!["code".to_string(), "invite-code".to_string()]));
         assert_tags_json(group_join_request_tags(
             &serde_json::to_string(&GroupJoinRequest {
                 group_id: "field-group".to_string(),
                 message: Some("requesting access".to_string()),
                 code: Some("invite-code".to_string()),
             })
             .expect("join json"),
         ));
         assert_tags_json(group_leave_request_tags(
             &serde_json::to_string(&GroupLeaveRequest {
                 group_id: "field-group".to_string(),
                 message: Some("leaving".to_string()),
             })
             .expect("leave json"),
         ));
         let metadata_tags = tags_json(group_metadata_tags(
             &serde_json::to_string(&GroupMetadata {
                 d_tag: "field-group".to_string(),
                 metadata,
             })
             .expect("metadata json"),
         ));
         assert!(metadata_tags.contains(&vec!["restricted".to_string()]));
         assert!(metadata_tags.contains(&vec![
             "supported_kinds".to_string(),
             "78".to_string(),
             "30078".to_string(),
             KIND_FARM_FILE_METADATA.to_string()
         ]));
         assert_tags_json(group_admins_tags(
             &serde_json::to_string(&GroupAdmins {
                 d_tag: "field-group".to_string(),
                 description: Some("group admins".to_string()),
                 admins: vec![sample_group_user("admin")],
             })
             .expect("admins json"),
         ));
         assert_tags_json(group_members_tags(
             &serde_json::to_string(&GroupMembers {
                 d_tag: "field-group".to_string(),
                 description: Some("group members".to_string()),
                 members: vec![sample_group_user("member")],
             })
             .expect("members json"),
         ));
         assert_tags_json(group_roles_tags(
             &serde_json::to_string(&GroupRoles {
                 d_tag: "field-group".to_string(),
                 description: Some("group roles".to_string()),
                 roles: vec![sample_group_role()],
             })
             .expect("roles json"),
         ));
     }
 
     #[test]
     fn listing_bindings_surface_builder_errors() {
         let mut listing_json = serde_json::to_value(sample_listing()).expect("listing value");
         listing_json["bins"] = serde_json::Value::Array(Vec::new());
         let listing_json = serde_json::to_string(&listing_json).expect("listing json");
 
         assert!(operational_listing_tags(&listing_json).is_err());
         assert!(operational_listing_tags_full(&listing_json).is_err());
     }
 
     #[test]
     fn evidence_report_plan_and_signed_validation_use_final_contracts() {
         assert!(trade_evidence_manifest_parse_json("AA").is_err());
         assert!(
             rhi_evidence_attestation_validate_signed_json(
                 &"x".repeat(radroots_event::wire::v1::DEFAULT_RAW_JSON_MAX_BYTES + 1)
             )
             .is_err()
         );
 
         let fixture: serde_json::Value = serde_json::from_str(include_str!(
             "../../../contracts/conformance/vectors/event/authored_operations.v1.json"
         ))
         .expect("authored corpus");
         let expected = fixture["vectors"]
             .as_array()
             .expect("operations")
             .iter()
             .find(|entry| entry["id"] == "typed_rhi_evidence_attestation_017")
             .expect("RHI operation")
             .get("expected")
             .expect("expected");
         let content = expected["content"].as_str().expect("content");
 
         let report: serde_json::Value = serde_json::from_str(
             &rhi_evidence_report_parse_json(content).expect("report projection"),
         )
         .expect("report JSON");
         assert_eq!(report["outcome"], "indeterminate");
         assert_eq!(report["trade_generation"], "7");
 
         let plan: serde_json::Value = serde_json::from_str(
             &rhi_evidence_attestation_build_draft(content, 1_784_347_200).expect("typed plan"),
         )
         .expect("plan JSON");
         assert_eq!(plan["kind"], 3_441);
         assert_eq!(plan["created_at_unix_s"], "1784347200");
         assert_eq!(plan["expected_event_id"], expected["event_id"]);
 
         let raw: serde_json::Value =
             serde_json::from_str(expected["raw_json"].as_str().expect("signed event"))
                 .expect("raw event JSON");
         let boundary_event = serde_json::json!({
             "id": raw["id"],
             "author": raw["pubkey"],
             "created_at": raw["created_at"],
             "kind": raw["kind"],
             "tags": raw["tags"],
             "content": raw["content"],
             "sig": raw["sig"],
         });
         let attestation: serde_json::Value = serde_json::from_str(
             &rhi_evidence_attestation_validate_signed_json(&boundary_event.to_string())
                 .expect("verified attestation"),
         )
         .expect("attestation JSON");
         assert_eq!(attestation["outcome"], "indeterminate");
         assert_eq!(attestation["trade_generation"], "7");
 
         let secret = "private-report-content";
         let error = rhi_evidence_report_parse_json(secret).expect_err("malformed report");
         assert!(!format!("{error:?}").contains(secret));
 
         let decision_vectors: serde_json::Value = serde_json::from_str(include_str!(
             "../../../contracts/conformance/vectors/rhi/evidence_attestation_decision.v1.json"
         ))
         .expect("RHI decision corpus");
         let superseding = decision_vectors["vectors"]
             .as_array()
             .expect("RHI decision vectors")
             .iter()
             .find(|entry| entry["id"] == "rhi_evidence_attestation_superseding_002")
             .expect("superseding vector");
         let superseding_content = superseding["expected"]["canonical_event_content_utf8"]
             .as_str()
             .expect("superseding canonical content");
         let superseding_report: serde_json::Value = serde_json::from_str(
             &rhi_evidence_report_parse_json(superseding_content)
                 .expect("superseding report projection"),
         )
         .expect("superseding report JSON");
         assert_eq!(superseding_report["outcome"], "valid");
         assert_eq!(
             superseding_report["supersession"]["report_id"],
             "7777777777777777777777777777777777777777777777777777777777777777"
         );
         assert_eq!(
             superseding_report["supersession"]["event_id"],
             "8888888888888888888888888888888888888888888888888888888888888888"
         );
     }
 
     #[test]
     fn evidence_manifest_projection_covers_every_admitted_vocabulary() {
         assert_eq!(
             coverage_name(RadrootsTradeEvidenceCoverageV1::Missing),
             "missing"
         );
         assert_eq!(
             coverage_name(RadrootsTradeEvidenceCoverageV1::Partial),
             "partial"
         );
         assert_eq!(
             coverage_name(RadrootsTradeEvidenceCoverageV1::ScopeSatisfied),
             "scope_satisfied"
         );
         assert_eq!(
             coverage_name(RadrootsTradeEvidenceCoverageV1::Unsupported),
             "unsupported"
         );
         assert_eq!(outcome_name(RadrootsTradeEvidenceOutcomeV1::Valid), "valid");
         assert_eq!(
             outcome_name(RadrootsTradeEvidenceOutcomeV1::Invalid),
             "invalid"
         );
         assert_eq!(
             outcome_name(RadrootsTradeEvidenceOutcomeV1::Indeterminate),
             "indeterminate"
         );
         assert_eq!(
             attestation_outcome_name(RadrootsRhiEvidenceAttestationOutcomeV1::Valid),
             "valid"
         );
         assert_eq!(
             attestation_outcome_name(RadrootsRhiEvidenceAttestationOutcomeV1::Invalid),
             "invalid"
         );
         assert_eq!(
             attestation_outcome_name(RadrootsRhiEvidenceAttestationOutcomeV1::Indeterminate),
             "indeterminate"
         );
 
         let source = RadrootsTradeEvidenceManifestSourceResultV1::new(
             RadrootsTradeEvidenceSourceIdV1::parse("typed_source").expect("source id"),
             RadrootsTradeEvidenceSourceResultV1::new(
                 RadrootsTradeEvidenceSourceRequirementV1::Required,
                 RadrootsTradeEvidenceSourceCompletionV1::Complete,
                 0,
             )
             .expect("source result"),
             RadrootsTradeEvidenceSourceResultDigestV1::from_bytes([0x33; 32]),
         );
         let manifest = RadrootsTradeEvidenceManifestV1::new(
             TradeId::from_bytes([0x11; 16]),
             NonZeroU64::new(1).expect("nonzero generation"),
             RadrootsTradeEvidencePolicyDigestV1::from_bytes([0x22; 32]),
             1_800_000_000,
             RadrootsTradeEvidenceScopePrerequisitesV1::Satisfied,
             [source],
             [],
         )
         .expect("manifest");
         let canonical_hex = hex::encode(manifest.canonical_bytes());
         let projected: serde_json::Value = serde_json::from_str(
             &trade_evidence_manifest_parse_json(&canonical_hex).expect("manifest projection"),
         )
         .expect("manifest projection JSON");
         assert_eq!(projected["coverage"], "scope_satisfied");
         assert_eq!(projected["canonical_bytes_hex"], canonical_hex);
 
         assert!(trade_evidence_manifest_parse_json("0").is_err());
         assert!(
             trade_evidence_manifest_parse_json(&"0".repeat(
                 radroots_trade::evidence::RADROOTS_TRADE_EVIDENCE_MANIFEST_MAXIMUM_BYTES * 2 + 2
             ))
             .is_err()
         );
     }
 }