lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

catalog.rs (69957B)


      1 use std::{
      2     collections::{BTreeMap, BTreeSet},
      3     fs,
      4     path::{Component, Path},
      5     process::Command,
      6 };
      7 
      8 use serde::Deserialize;
      9 use sha2::{Digest, Sha256};
     10 
     11 use crate::contract::artifact_bundle::{
     12     GeneratedArtifact, read_regular_file, with_artifact_bundle_transaction,
     13 };
     14 
     15 const CATALOG_RELATIVE: &str = "contracts/crates/catalog.v2.toml";
     16 const RELEASE_RELATIVE: &str = "contracts/crates/release.v2.toml";
     17 const CONSOLIDATION_RELATIVE: &str = "contracts/consolidation/architecture.v1.toml";
     18 const GROUPS_RELATIVE: &str = "contracts/crates/generated/package_groups.v1.toml";
     19 const PLATFORMS_RELATIVE: &str = "contracts/crates/generated/platform_inventory.v1.toml";
     20 const RELEASE_INVENTORY_RELATIVE: &str = "contracts/crates/generated/release_inventory.v2.toml";
     21 const COVERAGE_RELATIVE: &str = "contracts/coverage.toml";
     22 const CATALOG_SCHEMA: &str = "radroots.workspace.catalog.v2";
     23 const RELEASE_ID: &str = "radroots.crates.release.v2";
     24 const CONSOLIDATION_ID: &str = "radroots.rust.consolidation.v1";
     25 const VERSION: &str = "0.1.0-alpha";
     26 // Implemented public owners from the approved shared SDK target. Native
     27 // introduction provenance is independent of publication eligibility.
     28 const NATIVE_PUBLIC_PACKAGES: &[&str] = &[
     29     "radroots_domain",
     30     "radroots_execution",
     31     "radroots_transport_nostr_native",
     32 ];
     33 const APPLICATION_RETIREMENT: &str =
     34     "contracts/architecture/decisions/tera_application_ownership.v1.json";
     35 const RETIRED_APPLICATION_PACKAGES: [&str; 4] = [
     36     "radroots_mobile_bindgen",
     37     "radroots_mobile_core",
     38     "radroots_mobile_ffi",
     39     "radroots_mobile_wasm",
     40 ];
     41 
     42 #[derive(Debug, Deserialize)]
     43 #[serde(deny_unknown_fields)]
     44 struct ApplicationRetirement {
     45     schema: String,
     46     source_repository: String,
     47     source_catalog_revision: String,
     48     source_catalog_sha256: String,
     49     transfer_donor_commit: String,
     50     transfer_donor_tree: String,
     51     target_repository: String,
     52     target_revision: String,
     53     transfer_evidence_sha256: String,
     54     package: Vec<RetiredApplication>,
     55 }
     56 
     57 #[derive(Debug, Deserialize)]
     58 #[serde(deny_unknown_fields)]
     59 struct RetiredApplication {
     60     former_catalog_entry: CatalogPackage,
     61     target_name: String,
     62     target_path: String,
     63     projected_commit: String,
     64     projected_tree: String,
     65 }
     66 
     67 #[derive(Debug, Deserialize)]
     68 #[serde(deny_unknown_fields)]
     69 struct Catalog {
     70     schema_version: u16,
     71     schema: String,
     72     architecture: String,
     73     consolidation: String,
     74     version: String,
     75     rust_version: String,
     76     edition: String,
     77     resolver: String,
     78     public_package_count: usize,
     79     package_count: usize,
     80     digest_algorithm: String,
     81     source_tree_digest_algorithm: String,
     82     native_introduction_tree_digest_algorithm: String,
     83     source_provenance_policy: String,
     84     provenance_correction_contract: String,
     85     retired_packages: Vec<String>,
     86     package: Vec<CatalogPackage>,
     87 }
     88 
     89 #[derive(Debug, Deserialize)]
     90 #[serde(deny_unknown_fields)]
     91 struct CatalogPackage {
     92     name: String,
     93     path: String,
     94     state: String,
     95     tier: String,
     96     visibility: String,
     97     publish: bool,
     98     version: String,
     99     license: String,
    100     platforms: Vec<String>,
    101     groups: Vec<String>,
    102     owners: Vec<String>,
    103     permitted_dependency_tiers: Vec<String>,
    104     provenance_kind: String,
    105     source_repository: Option<String>,
    106     source_revision: Option<String>,
    107     source_path: Option<String>,
    108     source_tree_sha256: Option<String>,
    109     introduction_tree_sha256: Option<String>,
    110     compatibility: Vec<String>,
    111     removal_gate: Option<String>,
    112     replaces: Vec<String>,
    113 }
    114 
    115 #[derive(Debug, Deserialize)]
    116 #[serde(deny_unknown_fields)]
    117 struct ReleaseV2 {
    118     schema_version: u16,
    119     spec_id: String,
    120     status: String,
    121     supersedes_without_mutation: String,
    122     canonical_repository: String,
    123     version: String,
    124     public_package_count: usize,
    125     publication_authorized: bool,
    126     public_packages: Vec<String>,
    127     v1_artifact: Vec<V1Artifact>,
    128     v1_retired_human_artifact: Vec<RetiredV1HumanArtifact>,
    129 }
    130 
    131 #[derive(Debug, Deserialize)]
    132 #[serde(deny_unknown_fields)]
    133 struct V1Artifact {
    134     path: String,
    135     sha256: String,
    136 }
    137 
    138 #[derive(Debug, Deserialize)]
    139 #[serde(deny_unknown_fields)]
    140 struct RetiredV1HumanArtifact {
    141     former_path: String,
    142     sha256: String,
    143 }
    144 
    145 #[derive(Debug, Deserialize)]
    146 #[serde(deny_unknown_fields)]
    147 struct ConsolidationV1 {
    148     schema_version: u16,
    149     consolidation_id: String,
    150     architecture: String,
    151     canonical_rust_repository: String,
    152     donor_repositories: Vec<String>,
    153     consumer_repositories: Vec<String>,
    154     source_retirement_requires: Vec<String>,
    155     repository_archival_requires: Vec<String>,
    156 }
    157 
    158 #[derive(Debug, Deserialize)]
    159 struct CoveragePolicy {
    160     required: CoverageRequired,
    161 }
    162 
    163 #[derive(Debug, Deserialize)]
    164 struct CoverageRequired {
    165     crates: Vec<String>,
    166 }
    167 
    168 #[derive(Debug, Deserialize)]
    169 struct CargoMetadata {
    170     packages: Vec<CargoPackage>,
    171     workspace_members: Vec<String>,
    172 }
    173 
    174 #[derive(Debug, Deserialize)]
    175 struct CargoPackage {
    176     id: String,
    177     name: String,
    178     version: String,
    179     manifest_path: String,
    180     license: Option<String>,
    181     publish: Option<Vec<String>>,
    182     dependencies: Vec<CargoDependency>,
    183 }
    184 
    185 #[derive(Debug, Deserialize)]
    186 struct CargoDependency {
    187     name: String,
    188     source: Option<String>,
    189     req: String,
    190     path: Option<String>,
    191     kind: Option<String>,
    192     target: Option<String>,
    193 }
    194 
    195 pub fn run(args: &[String], workspace_root: &Path) -> Result<(), String> {
    196     match args {
    197         [command] if command == "check" => check(workspace_root),
    198         [command] if command == "write" => write(workspace_root),
    199         _ => Err("catalog accepts check or write".to_owned()),
    200     }
    201 }
    202 
    203 pub(crate) fn check(workspace_root: &Path) -> Result<(), String> {
    204     check_with_provenance(workspace_root, true)
    205 }
    206 
    207 pub(crate) fn check_source_export(workspace_root: &Path) -> Result<(), String> {
    208     check_with_provenance(workspace_root, false)
    209 }
    210 
    211 pub(crate) fn active_group(workspace_root: &Path, group: &str) -> Result<Vec<String>, String> {
    212     validate_identifier(group, "package group")?;
    213     active_packages_matching(workspace_root, |package| {
    214         package.groups.iter().any(|candidate| candidate == group)
    215     })
    216 }
    217 
    218 pub(crate) fn active_packages(workspace_root: &Path) -> Result<Vec<String>, String> {
    219     active_packages_matching(workspace_root, |_| true)
    220 }
    221 
    222 pub(crate) fn public_packages(workspace_root: &Path) -> Result<Vec<String>, String> {
    223     let catalog = parse_file::<Catalog>(workspace_root, CATALOG_RELATIVE)?;
    224     validate_catalog(&catalog)?;
    225     let release = parse_file::<ReleaseV2>(workspace_root, RELEASE_RELATIVE)?;
    226     validate_release(&release, &catalog, workspace_root)?;
    227     Ok(release.public_packages)
    228 }
    229 
    230 fn active_packages_matching(
    231     workspace_root: &Path,
    232     predicate: impl Fn(&CatalogPackage) -> bool,
    233 ) -> Result<Vec<String>, String> {
    234     let catalog = parse_file::<Catalog>(workspace_root, CATALOG_RELATIVE)?;
    235     validate_catalog(&catalog)?;
    236     validate_application_retirement(&catalog, workspace_root)?;
    237     let mut packages = catalog
    238         .package
    239         .iter()
    240         .filter(|package| package.state == "active" && predicate(package))
    241         .map(|package| package.name.clone())
    242         .collect::<Vec<_>>();
    243     packages.sort_unstable();
    244     Ok(packages)
    245 }
    246 
    247 fn check_with_provenance(
    248     workspace_root: &Path,
    249     require_git_provenance: bool,
    250 ) -> Result<(), String> {
    251     let loaded = load_and_validate(workspace_root, require_git_provenance)?;
    252     for artifact in render_projections(&loaded.catalog, &loaded.catalog_digest) {
    253         let current = read_regular_file(workspace_root, artifact.relative)?;
    254         if current != artifact.contents {
    255             return Err(format!(
    256                 "generated catalog projection {} is stale; run catalog write",
    257                 artifact.relative
    258             ));
    259         }
    260     }
    261     Ok(())
    262 }
    263 
    264 fn write(workspace_root: &Path) -> Result<(), String> {
    265     let loaded = load_and_validate(workspace_root, true)?;
    266     let artifacts = render_projections(&loaded.catalog, &loaded.catalog_digest);
    267     with_artifact_bundle_transaction(workspace_root, |transaction| transaction.write(artifacts))
    268 }
    269 
    270 struct LoadedCatalog {
    271     catalog: Catalog,
    272     catalog_digest: String,
    273 }
    274 
    275 fn load_and_validate(
    276     workspace_root: &Path,
    277     require_git_provenance: bool,
    278 ) -> Result<LoadedCatalog, String> {
    279     let catalog_bytes = read_regular_file(workspace_root, CATALOG_RELATIVE)?;
    280     let catalog = parse_toml::<Catalog>(CATALOG_RELATIVE, &catalog_bytes)?;
    281     let release = parse_file::<ReleaseV2>(workspace_root, RELEASE_RELATIVE)?;
    282     let consolidation = parse_file::<ConsolidationV1>(workspace_root, CONSOLIDATION_RELATIVE)?;
    283     let coverage = parse_file::<CoveragePolicy>(workspace_root, COVERAGE_RELATIVE)?;
    284     validate_catalog(&catalog)?;
    285     validate_application_retirement(&catalog, workspace_root)?;
    286     validate_coverage_authority(&catalog, &coverage)?;
    287     validate_release(&release, &catalog, workspace_root)?;
    288     validate_consolidation(&consolidation)?;
    289     validate_workspace_manifest(&catalog, workspace_root)?;
    290     let metadata = cargo_metadata(workspace_root)?;
    291     validate_metadata(&catalog, &metadata, workspace_root)?;
    292     if require_git_provenance {
    293         validate_active_source_provenance(&catalog, workspace_root)?;
    294     }
    295     Ok(LoadedCatalog {
    296         catalog,
    297         catalog_digest: sha256(&catalog_bytes),
    298     })
    299 }
    300 
    301 fn parse_file<T: for<'de> Deserialize<'de>>(
    302     workspace_root: &Path,
    303     relative: &str,
    304 ) -> Result<T, String> {
    305     let bytes = read_regular_file(workspace_root, relative)?;
    306     parse_toml(relative, &bytes)
    307 }
    308 
    309 fn parse_toml<T: for<'de> Deserialize<'de>>(relative: &str, bytes: &[u8]) -> Result<T, String> {
    310     let raw =
    311         std::str::from_utf8(bytes).map_err(|error| format!("{relative} is not UTF-8: {error}"))?;
    312     toml::from_str(raw).map_err(|error| format!("parse {relative}: {error}"))
    313 }
    314 
    315 fn validate_catalog(catalog: &Catalog) -> Result<(), String> {
    316     if catalog.schema_version != 2
    317         || catalog.schema != CATALOG_SCHEMA
    318         || catalog.architecture != RELEASE_ID
    319         || catalog.consolidation != CONSOLIDATION_ID
    320         || catalog.version != VERSION
    321         || catalog.rust_version != crate::architecture::STABLE_TOOLCHAIN
    322         || catalog.edition != "2024"
    323         || catalog.resolver != "3"
    324         || catalog.public_package_count != expected_public_packages().len()
    325         || catalog.package_count != catalog.package.len()
    326         || catalog.digest_algorithm != "sha256-raw-bytes-v1"
    327         || catalog.source_tree_digest_algorithm != "sha256-git-ls-tree-r-v1"
    328         || catalog.native_introduction_tree_digest_algorithm != "sha256-git-tree-records-z-v1"
    329         || catalog.source_provenance_policy != "imported_revision_tree_or_native_introduction_tree"
    330         || catalog.provenance_correction_contract != "approved_correction_record_required"
    331     {
    332         return Err("catalog identity, toolchain, or cardinality drifted".to_owned());
    333     }
    334 
    335     let expected_public = expected_public_packages();
    336     let allowed_states = BTreeSet::from(["active", "reserved_import", "reserved_refactor"]);
    337     let allowed_visibilities = BTreeSet::from([
    338         "public_release",
    339         "private_runtime",
    340         "private_adapter",
    341         "private_boundary",
    342         "private_codegen",
    343         "private_fixture",
    344         "private_tool",
    345     ]);
    346     let allowed_licenses = BTreeSet::from([
    347         "MIT OR Apache-2.0",
    348         "GPL-3.0-only",
    349         "GPL-3.0-or-later",
    350         "MPL-2.0",
    351     ]);
    352     let mut names = BTreeSet::new();
    353     let mut paths = BTreeSet::new();
    354     let mut public = BTreeSet::new();
    355     let mut package_by_name = BTreeMap::new();
    356     let mut groups = BTreeSet::new();
    357     for package in &catalog.package {
    358         validate_identifier(&package.name, "package name")?;
    359         validate_relative_path(&package.path)?;
    360         validate_identifier(&package.tier, "package tier")?;
    361         let expected_path = match package.name.as_str() {
    362             "radroots" => "crates/radroots".to_owned(),
    363             // shared_sdk_refactor.v1.json fixes the browser artifact-root path.
    364             "radroots_browser" => "crates/radroots_browser".to_owned(),
    365             // The same approved decision fixes the concrete native boundary.
    366             "radroots_ffi" => "crates/radroots_ffi".to_owned(),
    367             "xtask" => "tools/xtask".to_owned(),
    368             name => format!(
    369                 "crates/{}",
    370                 name.strip_prefix("radroots_")
    371                     .ok_or_else(|| format!("package {name} lacks the radroots_ prefix"))?
    372             ),
    373         };
    374         if package.path != expected_path {
    375             return Err(format!(
    376                 "package {} must use canonical path {expected_path}",
    377                 package.name
    378             ));
    379         }
    380         if !names.insert(package.name.as_str()) || !paths.insert(package.path.as_str()) {
    381             return Err(format!(
    382                 "duplicate package name or path for {}",
    383                 package.name
    384             ));
    385         }
    386         if !allowed_states.contains(package.state.as_str())
    387             || !allowed_visibilities.contains(package.visibility.as_str())
    388             || !allowed_licenses.contains(package.license.as_str())
    389             || package.version != VERSION
    390             || package.platforms.is_empty()
    391             || package.groups.is_empty()
    392             || package.owners.is_empty()
    393             || package.permitted_dependency_tiers.is_empty()
    394             || package.compatibility.is_empty()
    395         {
    396             return Err(format!("catalog package {} is incomplete", package.name));
    397         }
    398         validate_unique_identifiers(&package.platforms, "platform")?;
    399         validate_unique_identifiers(&package.groups, "group")?;
    400         validate_unique_identifiers(&package.owners, "owner")?;
    401         validate_unique_identifiers(
    402             &package.permitted_dependency_tiers,
    403             "permitted dependency tier",
    404         )?;
    405         validate_unique_identifiers(&package.compatibility, "compatibility authority")?;
    406         for group in &package.groups {
    407             groups.insert(group.as_str());
    408         }
    409         if package.visibility == "public_release" {
    410             public.insert(package.name.as_str());
    411             if !package.publish || package.license != "MIT OR Apache-2.0" {
    412                 return Err(format!(
    413                     "public package {} must be permissive and publication-eligible",
    414                     package.name
    415                 ));
    416             }
    417         } else if package.publish {
    418             return Err(format!(
    419                 "private package {} must set publish=false",
    420                 package.name
    421             ));
    422         }
    423         if package.license.starts_with("GPL-")
    424             && !matches!(
    425                 package.visibility.as_str(),
    426                 "private_runtime" | "private_adapter" | "private_boundary" | "private_codegen"
    427             )
    428         {
    429             return Err(format!("GPL package {} has an invalid class", package.name));
    430         }
    431         validate_package_provenance(package)?;
    432         for replaced in &package.replaces {
    433             validate_package_identity(replaced, "replaced package")?;
    434         }
    435         if package.state == "active" && package.removal_gate.is_some() {
    436             return Err(format!(
    437                 "active package {} has a removal gate",
    438                 package.name
    439             ));
    440         }
    441         if package.state != "active"
    442             && package
    443                 .removal_gate
    444                 .as_deref()
    445                 .is_none_or(|gate| gate.trim().is_empty())
    446         {
    447             return Err(format!(
    448                 "reserved package {} lacks a removal gate",
    449                 package.name
    450             ));
    451         }
    452         package_by_name.insert(package.name.as_str(), package);
    453     }
    454     if public != expected_public {
    455         return Err("catalog must contain exactly the approved public allocation".to_owned());
    456     }
    457     let required_groups = BTreeSet::from([
    458         "boundaries",
    459         "coverage_required",
    460         "portable",
    461         "preview",
    462         "public_native",
    463         "sdk",
    464         "tools",
    465         "wasm",
    466     ]);
    467     if !required_groups.is_subset(&groups) {
    468         return Err("catalog is missing one or more required package groups".to_owned());
    469     }
    470     let portable = catalog
    471         .package
    472         .iter()
    473         .filter(|package| package.groups.iter().any(|group| group == "portable"))
    474         .map(|package| package.name.as_str())
    475         .collect::<BTreeSet<_>>();
    476     if portable != expected_public {
    477         return Err("portable group must contain exactly the public allocation".to_owned());
    478     }
    479     for package in &catalog.package {
    480         for tier in &package.permitted_dependency_tiers {
    481             if !catalog
    482                 .package
    483                 .iter()
    484                 .any(|candidate| candidate.tier == *tier)
    485             {
    486                 return Err(format!(
    487                     "package {} permits unknown tier {tier}",
    488                     package.name
    489                 ));
    490             }
    491         }
    492     }
    493     let retired = catalog
    494         .retired_packages
    495         .iter()
    496         .map(String::as_str)
    497         .collect::<BTreeSet<_>>();
    498     if retired.len() != catalog.retired_packages.len()
    499         || retired
    500             .iter()
    501             .any(|name| package_by_name.contains_key(name))
    502         || !expected_retired_packages().is_subset(&retired)
    503     {
    504         return Err("retired package identities are incomplete or reused".to_owned());
    505     }
    506     let xtasks = catalog
    507         .package
    508         .iter()
    509         .filter(|package| package.name == "xtask")
    510         .collect::<Vec<_>>();
    511     if xtasks.len() != 1
    512         || xtasks[0].path != "tools/xtask"
    513         || xtasks[0].visibility != "private_tool"
    514         || xtasks[0].state != "active"
    515     {
    516         return Err("catalog must contain exactly one canonical xtask".to_owned());
    517     }
    518     Ok(())
    519 }
    520 
    521 fn validate_package_provenance(package: &CatalogPackage) -> Result<(), String> {
    522     match package.provenance_kind.as_str() {
    523         "imported" => {
    524             let source_repository = package.source_repository.as_deref().ok_or_else(|| {
    525                 format!("imported package {} lacks source repository", package.name)
    526             })?;
    527             let source_revision = package.source_revision.as_deref().ok_or_else(|| {
    528                 format!("imported package {} lacks source revision", package.name)
    529             })?;
    530             let source_path = package
    531                 .source_path
    532                 .as_deref()
    533                 .ok_or_else(|| format!("imported package {} lacks source path", package.name))?;
    534             let source_tree_sha256 = package.source_tree_sha256.as_deref().ok_or_else(|| {
    535                 format!("imported package {} lacks source tree digest", package.name)
    536             })?;
    537             if package.introduction_tree_sha256.is_some() {
    538                 return Err(format!(
    539                     "imported package {} declares native introduction provenance",
    540                     package.name
    541                 ));
    542             }
    543             if source_repository
    544                 != format!(
    545                     "https://github.com/radrootslabs/{}",
    546                     source_repository_name(source_repository)?
    547                 )
    548             {
    549                 return Err(format!(
    550                     "package {} source repository is noncanonical",
    551                     package.name
    552                 ));
    553             }
    554             validate_oid(source_revision, "source revision")?;
    555             validate_relative_path(source_path)?;
    556             validate_sha256(source_tree_sha256, "source tree digest")
    557         }
    558         "native" => {
    559             if package.source_repository.is_some()
    560                 || package.source_revision.is_some()
    561                 || package.source_path.is_some()
    562                 || package.source_tree_sha256.is_some()
    563             {
    564                 return Err(format!(
    565                     "native package {} must not declare imported provenance",
    566                     package.name
    567                 ));
    568             }
    569             let introduction_tree_sha256 =
    570                 package.introduction_tree_sha256.as_deref().ok_or_else(|| {
    571                     format!(
    572                         "native package {} lacks introduction tree digest",
    573                         package.name
    574                     )
    575                 })?;
    576             validate_sha256(introduction_tree_sha256, "introduction tree digest")?;
    577             let public = package.publish || package.visibility == "public_release";
    578             if package.state != "active"
    579                 || (public
    580                     && (!NATIVE_PUBLIC_PACKAGES.contains(&package.name.as_str())
    581                         || !package.publish
    582                         || package.visibility != "public_release"))
    583             {
    584                 return Err(format!(
    585                     "native package {} must be active and use its approved publication boundary",
    586                     package.name
    587                 ));
    588             }
    589             Ok(())
    590         }
    591         _ => Err(format!(
    592             "package {} has unknown provenance kind {}",
    593             package.name, package.provenance_kind
    594         )),
    595     }
    596 }
    597 
    598 fn validate_coverage_authority(catalog: &Catalog, coverage: &CoveragePolicy) -> Result<(), String> {
    599     let catalog_required = catalog
    600         .package
    601         .iter()
    602         .filter(|package| {
    603             package.state == "active"
    604                 && package
    605                     .groups
    606                     .iter()
    607                     .any(|group| group == "coverage_required")
    608         })
    609         .map(|package| package.name.as_str())
    610         .collect::<BTreeSet<_>>();
    611     let policy_required = coverage
    612         .required
    613         .crates
    614         .iter()
    615         .map(String::as_str)
    616         .collect::<BTreeSet<_>>();
    617     if policy_required.len() != coverage.required.crates.len() {
    618         return Err("coverage policy contains duplicate required packages".to_owned());
    619     }
    620     if catalog_required != policy_required {
    621         return Err(
    622             "coverage required packages must exactly match the catalog coverage_required group"
    623                 .to_owned(),
    624         );
    625     }
    626     Ok(())
    627 }
    628 
    629 fn validate_release(
    630     release: &ReleaseV2,
    631     catalog: &Catalog,
    632     workspace_root: &Path,
    633 ) -> Result<(), String> {
    634     if release.schema_version != 2
    635         || release.spec_id != RELEASE_ID
    636         || release.status != "approved_not_published"
    637         || release.supersedes_without_mutation != "radroots.crates.release.v1"
    638         || release.canonical_repository != "https://github.com/radrootslabs/lib"
    639         || release.version != VERSION
    640         || release.public_package_count != expected_public_packages().len()
    641         || release.publication_authorized
    642         || release
    643             .public_packages
    644             .iter()
    645             .map(String::as_str)
    646             .collect::<BTreeSet<_>>()
    647             != expected_public_packages()
    648     {
    649         return Err("release v2 identity or public allocation drifted".to_owned());
    650     }
    651     if release.public_packages.len() != release.public_package_count
    652         || catalog.public_package_count != release.public_package_count
    653     {
    654         return Err("release v2 package cardinality drifted".to_owned());
    655     }
    656     let mut paths = BTreeSet::new();
    657     for artifact in &release.v1_artifact {
    658         validate_relative_path(&artifact.path)?;
    659         validate_sha256(&artifact.sha256, "v1 artifact digest")?;
    660         if !paths.insert(artifact.path.as_str()) {
    661             return Err("release v2 repeats a v1 artifact".to_owned());
    662         }
    663         let bytes = read_regular_file(workspace_root, &artifact.path)?;
    664         if sha256(&bytes) != artifact.sha256 {
    665             return Err(format!("historical v1 artifact {} drifted", artifact.path));
    666         }
    667     }
    668     let expected = BTreeSet::from([
    669         "contracts/crates/release_v1/radroots_crates_release_v1.dot",
    670         "contracts/crates/release_v1/radroots_crates_release_v1.sha256",
    671         "contracts/crates/release_v1/radroots_crates_release_v1.toml",
    672         "contracts/crates/release_v1/radroots_crates_release_v1_inventory.csv",
    673     ]);
    674     if paths != expected {
    675         return Err("release v2 must pin every historical v1 machine artifact".to_owned());
    676     }
    677     if release.v1_retired_human_artifact.len() != 1 {
    678         return Err("release v2 must record the retired v1 human artifact".to_owned());
    679     }
    680     let retired = &release.v1_retired_human_artifact[0];
    681     validate_relative_path(&retired.former_path)?;
    682     validate_sha256(&retired.sha256, "retired v1 human artifact digest")?;
    683     if retired.former_path != "docs/specs/radroots_crates_release_v1.md"
    684         || retired.sha256 != "ea2c1f0f5c53fae56a247ae7519b065c9a0d62dafb998b75a48075f4a875b5eb"
    685     {
    686         return Err("release v2 retired v1 human artifact drifted".to_owned());
    687     }
    688     Ok(())
    689 }
    690 
    691 fn validate_consolidation(contract: &ConsolidationV1) -> Result<(), String> {
    692     if contract.schema_version != 1
    693         || contract.consolidation_id != CONSOLIDATION_ID
    694         || contract.architecture != RELEASE_ID
    695         || contract.canonical_rust_repository != "https://github.com/radrootslabs/lib"
    696         || contract
    697             .donor_repositories
    698             .iter()
    699             .map(String::as_str)
    700             .collect::<BTreeSet<_>>()
    701             != BTreeSet::from([
    702                 "https://github.com/radrootslabs/app_rt",
    703                 "https://github.com/radrootslabs/sdk",
    704                 "https://github.com/radrootslabs/studio_app",
    705             ])
    706         || contract
    707             .consumer_repositories
    708             .iter()
    709             .map(String::as_str)
    710             .collect::<BTreeSet<_>>()
    711             != BTreeSet::from([
    712                 "https://github.com/radrootslabs/sdk",
    713                 "https://github.com/radrootslabs/studio_app",
    714             ])
    715         || contract.source_retirement_requires.is_empty()
    716         || contract.repository_archival_requires.is_empty()
    717     {
    718         return Err("consolidation v1 repository authority drifted".to_owned());
    719     }
    720     validate_unique_identifiers(
    721         &contract.source_retirement_requires,
    722         "source retirement requirement",
    723     )?;
    724     validate_unique_identifiers(
    725         &contract.repository_archival_requires,
    726         "repository archival requirement",
    727     )
    728 }
    729 
    730 fn cargo_metadata(workspace_root: &Path) -> Result<CargoMetadata, String> {
    731     let output = Command::new("cargo")
    732         .args(["metadata", "--format-version", "1", "--locked", "--no-deps"])
    733         .current_dir(workspace_root)
    734         .output()
    735         .map_err(|error| format!("run cargo metadata: {error}"))?;
    736     if !output.status.success() {
    737         return Err(format!(
    738             "cargo metadata failed: {}",
    739             String::from_utf8_lossy(&output.stderr).trim()
    740         ));
    741     }
    742     serde_json::from_slice(&output.stdout)
    743         .map_err(|error| format!("parse cargo metadata output: {error}"))
    744 }
    745 
    746 fn validate_workspace_manifest(catalog: &Catalog, workspace_root: &Path) -> Result<(), String> {
    747     let bytes = read_regular_file(workspace_root, "Cargo.toml")?;
    748     let raw =
    749         std::str::from_utf8(&bytes).map_err(|error| format!("Cargo.toml is not UTF-8: {error}"))?;
    750     let manifest =
    751         toml::from_str::<toml::Value>(raw).map_err(|error| format!("parse Cargo.toml: {error}"))?;
    752     let workspace = manifest
    753         .get("workspace")
    754         .and_then(toml::Value::as_table)
    755         .ok_or_else(|| "Cargo.toml lacks [workspace]".to_owned())?;
    756     let members = workspace
    757         .get("members")
    758         .and_then(toml::Value::as_array)
    759         .ok_or_else(|| "Cargo.toml lacks explicit workspace members".to_owned())?
    760         .iter()
    761         .map(|value| {
    762             value
    763                 .as_str()
    764                 .ok_or_else(|| "workspace member must be a string".to_owned())
    765         })
    766         .collect::<Result<BTreeSet<_>, _>>()?;
    767     let active_paths = catalog
    768         .package
    769         .iter()
    770         .filter(|package| package.state == "active")
    771         .map(|package| package.path.as_str())
    772         .collect::<BTreeSet<_>>();
    773     if members != active_paths
    774         || members
    775             .iter()
    776             .any(|member| member.contains('*') || member.contains('?') || member.contains('['))
    777     {
    778         return Err(
    779             "Cargo workspace members must exactly match explicit active catalog paths".to_owned(),
    780         );
    781     }
    782     let default_members = workspace
    783         .get("default-members")
    784         .and_then(toml::Value::as_array)
    785         .ok_or_else(|| "Cargo.toml lacks explicit default members".to_owned())?
    786         .iter()
    787         .map(|value| {
    788             value
    789                 .as_str()
    790                 .ok_or_else(|| "default member must be a string".to_owned())
    791         })
    792         .collect::<Result<BTreeSet<_>, _>>()?;
    793     let expected_defaults = catalog
    794         .package
    795         .iter()
    796         .filter(|package| {
    797             package.state == "active"
    798                 && (package.groups.iter().any(|group| group == "portable")
    799                     || package.name == "xtask")
    800         })
    801         .map(|package| package.path.as_str())
    802         .collect::<BTreeSet<_>>();
    803     if default_members != expected_defaults {
    804         return Err(
    805             "Cargo default members must match active portable packages plus xtask".to_owned(),
    806         );
    807     }
    808     if workspace.get("resolver").and_then(toml::Value::as_str) != Some("3") {
    809         return Err("Cargo workspace resolver must remain 3".to_owned());
    810     }
    811     let dependencies = manifest
    812         .get("workspace")
    813         .and_then(|workspace| workspace.get("dependencies"))
    814         .and_then(toml::Value::as_table)
    815         .ok_or_else(|| "Cargo.toml lacks [workspace.dependencies]".to_owned())?;
    816     for (name, value) in dependencies {
    817         let name = value
    818             .get("package")
    819             .and_then(toml::Value::as_str)
    820             .unwrap_or(name);
    821         validate_foundation_dependency(name, value.get("git").and_then(toml::Value::as_str))?;
    822     }
    823     for package in catalog
    824         .package
    825         .iter()
    826         .filter(|package| package.state == "active" && package.name != "xtask")
    827     {
    828         let dependency = dependencies
    829             .get(&package.name)
    830             .and_then(toml::Value::as_table)
    831             .ok_or_else(|| format!("workspace dependency {} is missing", package.name))?;
    832         if dependency.get("path").and_then(toml::Value::as_str) != Some(package.path.as_str())
    833             || dependency.get("version").and_then(toml::Value::as_str)
    834                 != Some(format!("={VERSION}").as_str())
    835             || ["git", "rev", "branch", "tag"]
    836                 .iter()
    837                 .any(|key| dependency.contains_key(*key))
    838         {
    839             return Err(format!(
    840                 "workspace dependency {} must use its catalog path and exact version only",
    841                 package.name
    842             ));
    843         }
    844     }
    845     Ok(())
    846 }
    847 
    848 fn validate_foundation_dependency(name: &str, source: Option<&str>) -> Result<(), String> {
    849     if expected_retired_packages().contains(name)
    850         || name == "tera"
    851         || name.starts_with("tera_")
    852         || source.is_some_and(|source| source.contains("radrootslabs/tera"))
    853     {
    854         return Err(format!(
    855             "shared foundation cannot depend on retired or application package {name}"
    856         ));
    857     }
    858     Ok(())
    859 }
    860 
    861 fn validate_application_retirement(catalog: &Catalog, root: &Path) -> Result<(), String> {
    862     let bytes = read_regular_file(root, APPLICATION_RETIREMENT)?;
    863     let retirement: ApplicationRetirement = serde_json::from_slice(&bytes)
    864         .map_err(|error| format!("parse application ownership decision: {error}"))?;
    865     if retirement.schema != "radroots.tera.application-ownership.v1"
    866         || retirement.source_repository != "https://github.com/radrootslabs/lib"
    867         || retirement.target_repository != "https://github.com/radrootslabs/tera"
    868         || retirement.package.len() != RETIRED_APPLICATION_PACKAGES.len()
    869     {
    870         return Err("application ownership decision identity drifted".to_owned());
    871     }
    872     validate_oid(
    873         &retirement.source_catalog_revision,
    874         "former catalog revision",
    875     )?;
    876     validate_oid(
    877         &retirement.transfer_donor_commit,
    878         "application donor commit",
    879     )?;
    880     validate_oid(&retirement.transfer_donor_tree, "application donor tree")?;
    881     validate_oid(&retirement.target_revision, "application target revision")?;
    882     validate_sha256(&retirement.source_catalog_sha256, "former catalog digest")?;
    883     validate_sha256(
    884         &retirement.transfer_evidence_sha256,
    885         "transfer evidence digest",
    886     )?;
    887     let mut names = BTreeSet::new();
    888     for transferred in &retirement.package {
    889         let former = &transferred.former_catalog_entry;
    890         if !RETIRED_APPLICATION_PACKAGES.contains(&former.name.as_str())
    891             || !names.insert(former.name.as_str())
    892             || !catalog.retired_packages.contains(&former.name)
    893             || catalog
    894                 .package
    895                 .iter()
    896                 .any(|package| package.name == former.name)
    897             || former.state != "active"
    898             || former.publish
    899             || former.license != "GPL-3.0-or-later"
    900             || former.path != format!("crates/{}", former.name.trim_start_matches("radroots_"))
    901             || transferred.target_name != former.name.replacen("radroots_mobile_", "tera_", 1)
    902             || transferred.target_path != format!("core/crates/{}", transferred.target_name)
    903         {
    904             return Err(
    905                 "application package retirement or retained attribution drifted".to_owned(),
    906             );
    907         }
    908         validate_package_provenance(former)?;
    909         validate_oid(
    910             &transferred.projected_commit,
    911             "application projected commit",
    912         )?;
    913         validate_oid(&transferred.projected_tree, "application projected tree")?;
    914         match fs::symlink_metadata(root.join(&former.path)) {
    915             Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
    916             Err(error) => return Err(format!("inspect retired application path: {error}")),
    917             Ok(_) => {
    918                 return Err(format!(
    919                     "retired application path {} remains present",
    920                     former.path
    921                 ));
    922             }
    923         }
    924     }
    925     Ok(())
    926 }
    927 
    928 fn validate_metadata(
    929     catalog: &Catalog,
    930     metadata: &CargoMetadata,
    931     workspace_root: &Path,
    932 ) -> Result<(), String> {
    933     let workspace_ids = metadata
    934         .workspace_members
    935         .iter()
    936         .map(String::as_str)
    937         .collect::<BTreeSet<_>>();
    938     let workspace_packages = metadata
    939         .packages
    940         .iter()
    941         .filter(|package| workspace_ids.contains(package.id.as_str()))
    942         .map(|package| (package.name.as_str(), package))
    943         .collect::<BTreeMap<_, _>>();
    944     let catalog_by_name = catalog
    945         .package
    946         .iter()
    947         .map(|package| (package.name.as_str(), package))
    948         .collect::<BTreeMap<_, _>>();
    949     let active = catalog
    950         .package
    951         .iter()
    952         .filter(|package| package.state == "active")
    953         .map(|package| package.name.as_str())
    954         .collect::<BTreeSet<_>>();
    955     if workspace_packages.keys().copied().collect::<BTreeSet<_>>() != active {
    956         return Err("active catalog packages and Cargo workspace members differ".to_owned());
    957     }
    958     for package in catalog
    959         .package
    960         .iter()
    961         .filter(|package| package.state != "active")
    962     {
    963         if workspace_root.join(&package.path).exists() {
    964             return Err(format!(
    965                 "reserved package path {} exists before its catalog activation",
    966                 package.path
    967             ));
    968         }
    969     }
    970     let canonical_root = fs::canonicalize(workspace_root)
    971         .map_err(|error| format!("canonicalize {}: {error}", workspace_root.display()))?;
    972     for (name, cargo) in &workspace_packages {
    973         let package = catalog_by_name[name];
    974         let manifest = Path::new(&cargo.manifest_path);
    975         let relative_manifest = manifest
    976             .strip_prefix(&canonical_root)
    977             .map_err(|_| format!("manifest {} escapes workspace", manifest.display()))?;
    978         let actual_path = relative_manifest
    979             .parent()
    980             .ok_or_else(|| format!("manifest {} has no package root", manifest.display()))?
    981             .to_string_lossy()
    982             .replace('\\', "/");
    983         let cargo_publish = cargo
    984             .publish
    985             .as_ref()
    986             .is_some_and(|registries| !registries.is_empty());
    987         if package.path != actual_path
    988             || package.version != cargo.version
    989             || package.license != cargo.license.as_deref().unwrap_or("")
    990             || package.publish != cargo_publish
    991         {
    992             return Err(format!("catalog and Cargo metadata drifted for {name}"));
    993         }
    994         for dependency in &cargo.dependencies {
    995             validate_foundation_dependency(&dependency.name, dependency.source.as_deref())?;
    996             let Some(target) = catalog_by_name.get(dependency.name.as_str()) else {
    997                 continue;
    998             };
    999             if dependency.path.is_none() || dependency.req != format!("={VERSION}") {
   1000                 return Err(format!(
   1001                     "first-party dependency {name} -> {} must use path plus ={VERSION}",
   1002                     dependency.name
   1003                 ));
   1004             }
   1005             if !package
   1006                 .permitted_dependency_tiers
   1007                 .iter()
   1008                 .any(|tier| tier == &target.tier)
   1009             {
   1010                 return Err(format!(
   1011                     "catalog tier policy forbids {name} -> {} ({:?}, {:?})",
   1012                     dependency.name, dependency.kind, dependency.target
   1013                 ));
   1014             }
   1015             if package.visibility == "public_release" && target.visibility != "public_release" {
   1016                 return Err(format!(
   1017                     "public package {name} depends on private package {}",
   1018                     dependency.name
   1019                 ));
   1020             }
   1021             if package.license == "MIT OR Apache-2.0" && target.license.starts_with("GPL-") {
   1022                 return Err(format!(
   1023                     "permissive package {name} depends on GPL package {}",
   1024                     dependency.name
   1025                 ));
   1026             }
   1027         }
   1028     }
   1029     Ok(())
   1030 }
   1031 
   1032 fn validate_active_source_provenance(
   1033     catalog: &Catalog,
   1034     workspace_root: &Path,
   1035 ) -> Result<(), String> {
   1036     for package in catalog
   1037         .package
   1038         .iter()
   1039         .filter(|package| package.state == "active")
   1040     {
   1041         match package.provenance_kind.as_str() {
   1042             "imported"
   1043                 if package.source_repository.as_deref()
   1044                     == Some("https://github.com/radrootslabs/lib") =>
   1045             {
   1046                 validate_imported_source_provenance(package, workspace_root)?;
   1047             }
   1048             "native" => validate_native_source_provenance(package, workspace_root)?,
   1049             _ => {}
   1050         }
   1051     }
   1052     Ok(())
   1053 }
   1054 
   1055 fn validate_imported_source_provenance(
   1056     package: &CatalogPackage,
   1057     workspace_root: &Path,
   1058 ) -> Result<(), String> {
   1059     let source_revision = package
   1060         .source_revision
   1061         .as_deref()
   1062         .ok_or_else(|| format!("imported package {} lacks source revision", package.name))?;
   1063     let source_path = package
   1064         .source_path
   1065         .as_deref()
   1066         .ok_or_else(|| format!("imported package {} lacks source path", package.name))?;
   1067     let expected = package
   1068         .source_tree_sha256
   1069         .as_deref()
   1070         .ok_or_else(|| format!("imported package {} lacks source tree digest", package.name))?;
   1071     let output = Command::new("git")
   1072         .args(["ls-tree", "-r", source_revision, "--", source_path])
   1073         .current_dir(workspace_root)
   1074         .output()
   1075         .map_err(|error| format!("run git ls-tree for {}: {error}", package.name))?;
   1076     if !output.status.success() {
   1077         return Err(format!(
   1078             "source revision for {} is unavailable: {}",
   1079             package.name,
   1080             String::from_utf8_lossy(&output.stderr).trim()
   1081         ));
   1082     }
   1083     if sha256(&output.stdout) != expected {
   1084         return Err(format!(
   1085             "source tree provenance drifted for {}",
   1086             package.name
   1087         ));
   1088     }
   1089     Ok(())
   1090 }
   1091 
   1092 fn validate_native_source_provenance(
   1093     package: &CatalogPackage,
   1094     workspace_root: &Path,
   1095 ) -> Result<(), String> {
   1096     let expected = package
   1097         .introduction_tree_sha256
   1098         .as_deref()
   1099         .ok_or_else(|| format!("native package {} lacks introduction digest", package.name))?;
   1100     let introducing_commit = native_introducing_commit(workspace_root, &package.path)?;
   1101     let actual = if let Some(commit) = introducing_commit {
   1102         committed_tree_digest(workspace_root, &commit, &package.path)?
   1103     } else {
   1104         staged_tree_digest(workspace_root, &package.path)?
   1105     };
   1106     if actual != expected {
   1107         return Err(format!(
   1108             "native introduction tree provenance drifted for {}",
   1109             package.name
   1110         ));
   1111     }
   1112     Ok(())
   1113 }
   1114 
   1115 fn native_introducing_commit(
   1116     workspace_root: &Path,
   1117     package_path: &str,
   1118 ) -> Result<Option<String>, String> {
   1119     let output = Command::new("git")
   1120         .args([
   1121             "log",
   1122             "--format=%H",
   1123             "--diff-filter=A",
   1124             "--reverse",
   1125             "--no-renames",
   1126             "HEAD",
   1127             "--",
   1128             package_path,
   1129         ])
   1130         .current_dir(workspace_root)
   1131         .output()
   1132         .map_err(|error| format!("derive native introduction commit: {error}"))?;
   1133     if !output.status.success() {
   1134         return Err(format!(
   1135             "derive native introduction commit for {package_path}: {}",
   1136             String::from_utf8_lossy(&output.stderr).trim()
   1137         ));
   1138     }
   1139     let stdout = std::str::from_utf8(&output.stdout)
   1140         .map_err(|error| format!("native introduction history is not UTF-8: {error}"))?;
   1141     let Some(commit) = stdout.lines().next() else {
   1142         return Ok(None);
   1143     };
   1144     validate_oid(commit, "native introducing commit")?;
   1145     Ok(Some(commit.to_owned()))
   1146 }
   1147 
   1148 fn committed_tree_digest(
   1149     workspace_root: &Path,
   1150     commit: &str,
   1151     package_path: &str,
   1152 ) -> Result<String, String> {
   1153     let output = Command::new("git")
   1154         .args(["ls-tree", "-r", "-z", commit, "--", package_path])
   1155         .current_dir(workspace_root)
   1156         .output()
   1157         .map_err(|error| format!("read native introduction tree: {error}"))?;
   1158     if !output.status.success() {
   1159         return Err(format!(
   1160             "read native introduction tree for {package_path}: {}",
   1161             String::from_utf8_lossy(&output.stderr).trim()
   1162         ));
   1163     }
   1164     if output.stdout.is_empty() {
   1165         return Err(format!(
   1166             "native introducing commit {commit} has no tree at {package_path}"
   1167         ));
   1168     }
   1169     Ok(sha256(&output.stdout))
   1170 }
   1171 
   1172 fn staged_tree_digest(workspace_root: &Path, package_path: &str) -> Result<String, String> {
   1173     let output = Command::new("git")
   1174         .args(["ls-files", "--stage", "-z", "--", package_path])
   1175         .current_dir(workspace_root)
   1176         .output()
   1177         .map_err(|error| format!("read staged native tree: {error}"))?;
   1178     if !output.status.success() {
   1179         return Err(format!(
   1180             "read staged native tree for {package_path}: {}",
   1181             String::from_utf8_lossy(&output.stderr).trim()
   1182         ));
   1183     }
   1184     let records = canonical_staged_tree_records(&output.stdout)?;
   1185     if records.is_empty() {
   1186         return Err(format!(
   1187             "native package {package_path} has no committed introduction or staged tree"
   1188         ));
   1189     }
   1190     Ok(sha256(&records))
   1191 }
   1192 
   1193 fn canonical_staged_tree_records(input: &[u8]) -> Result<Vec<u8>, String> {
   1194     let mut output = Vec::new();
   1195     for record in input
   1196         .split(|byte| *byte == 0)
   1197         .filter(|record| !record.is_empty())
   1198     {
   1199         let tab = record
   1200             .iter()
   1201             .position(|byte| *byte == b'\t')
   1202             .ok_or_else(|| "staged tree record lacks a path separator".to_owned())?;
   1203         let header = std::str::from_utf8(&record[..tab])
   1204             .map_err(|error| format!("staged tree record header is not UTF-8: {error}"))?;
   1205         let fields = header.split(' ').collect::<Vec<_>>();
   1206         if fields.len() != 3 || fields[2] != "0" {
   1207             return Err("staged native tree must contain only stage-zero records".to_owned());
   1208         }
   1209         let mode = fields[0];
   1210         let oid = fields[1];
   1211         if mode.len() != 6 || !mode.bytes().all(|byte| matches!(byte, b'0'..=b'7')) {
   1212             return Err("staged native tree contains an invalid mode".to_owned());
   1213         }
   1214         validate_oid(oid, "staged native object")?;
   1215         if oid.bytes().all(|byte| byte == b'0') {
   1216             return Err("staged native tree contains an intent-to-add object".to_owned());
   1217         }
   1218         if record[tab + 1..].is_empty() {
   1219             return Err("staged native tree contains an empty path".to_owned());
   1220         }
   1221         let object_type = if mode == "160000" { "commit" } else { "blob" };
   1222         output.extend_from_slice(mode.as_bytes());
   1223         output.push(b' ');
   1224         output.extend_from_slice(object_type.as_bytes());
   1225         output.push(b' ');
   1226         output.extend_from_slice(oid.as_bytes());
   1227         output.push(b'\t');
   1228         output.extend_from_slice(&record[tab + 1..]);
   1229         output.push(0);
   1230     }
   1231     Ok(output)
   1232 }
   1233 
   1234 fn render_projections(catalog: &Catalog, digest: &str) -> Vec<GeneratedArtifact> {
   1235     let mut groups = BTreeMap::<&str, Vec<&str>>::new();
   1236     let mut active_groups = BTreeMap::<&str, Vec<&str>>::new();
   1237     let mut reserved_groups = BTreeMap::<&str, Vec<&str>>::new();
   1238     let mut platforms = BTreeMap::<&str, Vec<&str>>::new();
   1239     let mut public = Vec::new();
   1240     let mut private = Vec::new();
   1241     let mut reserved = Vec::new();
   1242     for package in &catalog.package {
   1243         for group in &package.groups {
   1244             groups.entry(group).or_default().push(&package.name);
   1245             if package.state == "active" {
   1246                 active_groups.entry(group).or_default().push(&package.name);
   1247             } else {
   1248                 reserved_groups
   1249                     .entry(group)
   1250                     .or_default()
   1251                     .push(&package.name);
   1252             }
   1253         }
   1254         for platform in &package.platforms {
   1255             platforms.entry(platform).or_default().push(&package.name);
   1256         }
   1257         if package.visibility == "public_release" {
   1258             public.push(package.name.as_str());
   1259         } else {
   1260             private.push(package.name.as_str());
   1261         }
   1262         if package.state != "active" {
   1263             reserved.push(package.name.as_str());
   1264         }
   1265     }
   1266     sort_map_values(&mut groups);
   1267     sort_map_values(&mut active_groups);
   1268     sort_map_values(&mut reserved_groups);
   1269     sort_map_values(&mut platforms);
   1270     public.sort_unstable();
   1271     private.sort_unstable();
   1272     reserved.sort_unstable();
   1273     vec![
   1274         GeneratedArtifact {
   1275             relative: GROUPS_RELATIVE,
   1276             contents: render_group_projection(
   1277                 digest,
   1278                 &groups,
   1279                 &active_groups,
   1280                 &reserved_groups,
   1281             )
   1282             .into_bytes(),
   1283         },
   1284         GeneratedArtifact {
   1285             relative: PLATFORMS_RELATIVE,
   1286             contents: render_map_projection(
   1287                 "radroots.workspace.platform-inventory.v1",
   1288                 digest,
   1289                 "platform",
   1290                 &platforms,
   1291             )
   1292             .into_bytes(),
   1293         },
   1294         GeneratedArtifact {
   1295             relative: RELEASE_INVENTORY_RELATIVE,
   1296             contents: format!(
   1297                 "schema = \"radroots.workspace.release-inventory.v2\"\ncatalog_sha256 = \"{digest}\"\narchitecture = \"{RELEASE_ID}\"\nversion = \"{VERSION}\"\npublic_packages = {}\nprivate_packages = {}\nreserved_packages = {}\n",
   1298                 toml_array(&public),
   1299                 toml_array(&private),
   1300                 toml_array(&reserved)
   1301             )
   1302             .into_bytes(),
   1303         },
   1304     ]
   1305 }
   1306 
   1307 fn render_group_projection(
   1308     digest: &str,
   1309     groups: &BTreeMap<&str, Vec<&str>>,
   1310     active: &BTreeMap<&str, Vec<&str>>,
   1311     reserved: &BTreeMap<&str, Vec<&str>>,
   1312 ) -> String {
   1313     let mut output = format!(
   1314         "schema = \"radroots.workspace.package-groups.v1\"\ncatalog_sha256 = \"{digest}\"\n"
   1315     );
   1316     for (id, packages) in groups {
   1317         output.push_str(&format!(
   1318             "\n[[group]]\nid = \"{id}\"\npackages = {}\nactive_packages = {}\nreserved_packages = {}\n",
   1319             toml_array(packages),
   1320             toml_array(active.get(id).map(Vec::as_slice).unwrap_or_default()),
   1321             toml_array(reserved.get(id).map(Vec::as_slice).unwrap_or_default()),
   1322         ));
   1323     }
   1324     output
   1325 }
   1326 
   1327 fn render_map_projection(
   1328     schema: &str,
   1329     digest: &str,
   1330     table: &str,
   1331     values: &BTreeMap<&str, Vec<&str>>,
   1332 ) -> String {
   1333     let mut output = format!("schema = \"{schema}\"\ncatalog_sha256 = \"{digest}\"\n");
   1334     for (id, packages) in values {
   1335         output.push_str(&format!(
   1336             "\n[[{table}]]\nid = \"{id}\"\npackages = {}\n",
   1337             toml_array(packages)
   1338         ));
   1339     }
   1340     output
   1341 }
   1342 
   1343 fn toml_array(values: &[&str]) -> String {
   1344     format!(
   1345         "[{}]",
   1346         values
   1347             .iter()
   1348             .map(|value| format!("\"{value}\""))
   1349             .collect::<Vec<_>>()
   1350             .join(", ")
   1351     )
   1352 }
   1353 
   1354 fn sort_map_values(values: &mut BTreeMap<&str, Vec<&str>>) {
   1355     for packages in values.values_mut() {
   1356         packages.sort_unstable();
   1357         packages.dedup();
   1358     }
   1359 }
   1360 
   1361 fn expected_public_packages() -> BTreeSet<&'static str> {
   1362     let mut packages = BTreeSet::from([
   1363         "radroots",
   1364         "radroots_blossom",
   1365         "radroots_core",
   1366         "radroots_event",
   1367         "radroots_event_codec",
   1368         "radroots_geonames",
   1369         "radroots_identity",
   1370         "radroots_nostr",
   1371         "radroots_nostr_connect",
   1372         "radroots_protocol",
   1373         "radroots_sdk",
   1374         "radroots_secrets",
   1375         "radroots_signing",
   1376         "radroots_storage",
   1377         "radroots_storage_sqlite",
   1378         "radroots_sync",
   1379         "radroots_trade",
   1380         "radroots_transport",
   1381         "radroots_transport_nostr",
   1382     ]);
   1383     packages.extend(NATIVE_PUBLIC_PACKAGES.iter().copied());
   1384     packages
   1385 }
   1386 
   1387 fn expected_retired_packages() -> BTreeSet<&'static str> {
   1388     BTreeSet::from([
   1389         "radroots-studio-application",
   1390         "radroots-studio-domain",
   1391         "radroots-studio-ffi",
   1392         "radroots-studio-nostr",
   1393         "radroots-studio-storage",
   1394         "radroots-studio-uniffi-bindgen",
   1395         "radroots_studio_application",
   1396         "radroots_studio_domain",
   1397         "radroots_studio_ffi",
   1398         "radroots_studio_nostr",
   1399         "radroots_studio_preferences",
   1400         "radroots_studio_runtime",
   1401         "radroots_studio_storage",
   1402         "radroots_studio_uniffi_bindgen",
   1403         "radroots_app_bindgen",
   1404         "radroots_app_core",
   1405         "radroots_app_ffi",
   1406         "radroots_app_wasm",
   1407         "radroots_mobile_bindgen",
   1408         "radroots_mobile_core",
   1409         "radroots_mobile_ffi",
   1410         "radroots_mobile_wasm",
   1411         "radroots_sdk_xtask",
   1412     ])
   1413 }
   1414 
   1415 fn validate_unique_identifiers(values: &[String], context: &str) -> Result<(), String> {
   1416     let mut unique = BTreeSet::new();
   1417     for value in values {
   1418         validate_identifier(value, context)?;
   1419         if !unique.insert(value.as_str()) {
   1420             return Err(format!("duplicate {context} {value}"));
   1421         }
   1422     }
   1423     Ok(())
   1424 }
   1425 
   1426 fn validate_identifier(value: &str, context: &str) -> Result<(), String> {
   1427     if value.is_empty()
   1428         || !value
   1429             .bytes()
   1430             .all(|byte| byte.is_ascii_lowercase() || byte.is_ascii_digit() || byte == b'_')
   1431     {
   1432         return Err(format!("{context} must use lowercase snake case"));
   1433     }
   1434     Ok(())
   1435 }
   1436 
   1437 fn validate_package_identity(value: &str, context: &str) -> Result<(), String> {
   1438     if value.is_empty()
   1439         || !value.bytes().all(|byte| {
   1440             byte.is_ascii_lowercase() || byte.is_ascii_digit() || matches!(byte, b'_' | b'-')
   1441         })
   1442     {
   1443         return Err(format!("{context} is invalid"));
   1444     }
   1445     Ok(())
   1446 }
   1447 
   1448 fn validate_relative_path(value: &str) -> Result<(), String> {
   1449     let path = Path::new(value);
   1450     if value.is_empty()
   1451         || path.is_absolute()
   1452         || value.contains('\\')
   1453         || value
   1454             .split('/')
   1455             .any(|segment| segment.is_empty() || matches!(segment, "." | ".."))
   1456         || path
   1457             .components()
   1458             .any(|component| !matches!(component, Component::Normal(_)))
   1459     {
   1460         return Err(format!("catalog path {value:?} is unsafe"));
   1461     }
   1462     Ok(())
   1463 }
   1464 
   1465 fn validate_oid(value: &str, context: &str) -> Result<(), String> {
   1466     if value.len() != 40
   1467         || !value
   1468             .bytes()
   1469             .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
   1470     {
   1471         return Err(format!("{context} must be lowercase full 40-hex"));
   1472     }
   1473     Ok(())
   1474 }
   1475 
   1476 fn validate_sha256(value: &str, context: &str) -> Result<(), String> {
   1477     if value.len() != 64
   1478         || !value
   1479             .bytes()
   1480             .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
   1481     {
   1482         return Err(format!("{context} must be lowercase 64-hex"));
   1483     }
   1484     Ok(())
   1485 }
   1486 
   1487 fn source_repository_name(url: &str) -> Result<&str, String> {
   1488     url.strip_prefix("https://github.com/radrootslabs/")
   1489         .filter(|name| {
   1490             !name.is_empty()
   1491                 && name
   1492                     .bytes()
   1493                     .all(|byte| byte.is_ascii_lowercase() || byte.is_ascii_digit() || byte == b'_')
   1494         })
   1495         .ok_or_else(|| format!("invalid canonical source repository {url}"))
   1496 }
   1497 
   1498 fn sha256(bytes: &[u8]) -> String {
   1499     format!("{:x}", Sha256::digest(bytes))
   1500 }
   1501 
   1502 #[cfg(test)]
   1503 mod tests {
   1504     use super::*;
   1505     use tempfile::TempDir;
   1506 
   1507     fn checked_in_catalog() -> Catalog {
   1508         parse_file(&crate::workspace_root(), CATALOG_RELATIVE).expect("checked-in catalog")
   1509     }
   1510 
   1511     fn git(root: &Path, args: &[&str]) {
   1512         let output = Command::new("git")
   1513             .args(args)
   1514             .current_dir(root)
   1515             .output()
   1516             .expect("run git fixture command");
   1517         assert!(
   1518             output.status.success(),
   1519             "git {} failed: {}",
   1520             args.join(" "),
   1521             String::from_utf8_lossy(&output.stderr)
   1522         );
   1523     }
   1524 
   1525     fn git_fixture() -> TempDir {
   1526         let root = tempfile::tempdir().expect("temporary git fixture");
   1527         git(root.path(), &["init", "--quiet"]);
   1528         git(root.path(), &["config", "user.name", "Catalog Test"]);
   1529         git(
   1530             root.path(),
   1531             &["config", "user.email", "catalog-test@example.invalid"],
   1532         );
   1533         fs::write(root.path().join("README.md"), "# Fixture\n").expect("baseline file");
   1534         git(root.path(), &["add", "README.md"]);
   1535         git(root.path(), &["commit", "--quiet", "-m", "baseline"]);
   1536         root
   1537     }
   1538 
   1539     fn native_package<'a>(
   1540         catalog: &'a mut Catalog,
   1541         path: &str,
   1542         digest: &str,
   1543     ) -> &'a mut CatalogPackage {
   1544         let package = catalog
   1545             .package
   1546             .iter_mut()
   1547             .find(|package| package.name == "radroots_nostrdb")
   1548             .expect("private package fixture");
   1549         package.path = path.to_owned();
   1550         package.provenance_kind = "native".to_owned();
   1551         package.source_repository = None;
   1552         package.source_revision = None;
   1553         package.source_path = None;
   1554         package.source_tree_sha256 = None;
   1555         package.introduction_tree_sha256 = Some(digest.to_owned());
   1556         package
   1557     }
   1558 
   1559     #[test]
   1560     fn public_inventory_is_exact() {
   1561         assert_eq!(expected_public_packages().len(), 22);
   1562         assert!(expected_public_packages().contains("radroots"));
   1563         assert!(expected_public_packages().contains("radroots_sdk"));
   1564     }
   1565 
   1566     #[test]
   1567     fn paths_and_digests_fail_closed() {
   1568         assert!(validate_relative_path("crates/sdk").is_ok());
   1569         assert!(validate_relative_path("../sdk").is_err());
   1570         assert!(validate_relative_path("crates/./sdk").is_err());
   1571         assert!(validate_sha256(&"a".repeat(64), "digest").is_ok());
   1572         assert!(validate_sha256(&"A".repeat(64), "digest").is_err());
   1573     }
   1574 
   1575     #[test]
   1576     fn browser_artifact_keeps_its_approved_directory_instead_of_prefix_stripping() {
   1577         let mut catalog = checked_in_catalog();
   1578         validate_catalog(&catalog).expect("approved catalog");
   1579         let browser = catalog
   1580             .package
   1581             .iter_mut()
   1582             .find(|package| package.name == "radroots_browser")
   1583             .expect("browser artifact");
   1584         assert_eq!(browser.path, "crates/radroots_browser");
   1585         browser.path = "crates/browser".to_owned();
   1586         assert!(validate_catalog(&catalog).is_err());
   1587     }
   1588 
   1589     #[test]
   1590     fn only_approved_shared_native_packages_can_be_public() {
   1591         for name in [
   1592             "radroots_domain",
   1593             "radroots_execution",
   1594             "radroots_transport_nostr_native",
   1595         ] {
   1596             let mut catalog = checked_in_catalog();
   1597             let package = catalog.package.iter_mut().find(|p| p.name == name).unwrap();
   1598             package.visibility = "public_release".to_owned();
   1599             package.publish = true;
   1600             validate_package_provenance(package).expect("approved native public allocation");
   1601             package.source_revision = Some("a".repeat(40));
   1602             assert!(validate_package_provenance(package).is_err());
   1603         }
   1604         let mut catalog = checked_in_catalog();
   1605         let other = native_package(&mut catalog, "crates/nostrdb", &"a".repeat(64));
   1606         other.visibility = "public_release".to_owned();
   1607         other.publish = true;
   1608         assert!(validate_package_provenance(other).is_err());
   1609     }
   1610 
   1611     #[test]
   1612     fn provenance_kinds_are_disjoint_and_native_is_unpublished() {
   1613         let mut catalog = checked_in_catalog();
   1614         let imported = catalog
   1615             .package
   1616             .iter_mut()
   1617             .find(|package| package.name == "radroots_core")
   1618             .expect("imported fixture");
   1619         imported.source_revision = None;
   1620         assert!(validate_package_provenance(imported).is_err());
   1621 
   1622         let mut catalog = checked_in_catalog();
   1623         let native = native_package(&mut catalog, "crates/nostrdb", &"a".repeat(64));
   1624         assert!(validate_package_provenance(native).is_ok());
   1625         native.source_revision = Some("a".repeat(40));
   1626         assert!(validate_package_provenance(native).is_err());
   1627 
   1628         let mut catalog = checked_in_catalog();
   1629         let public = catalog
   1630             .package
   1631             .iter_mut()
   1632             .find(|package| package.name == "radroots_core")
   1633             .expect("public fixture");
   1634         public.provenance_kind = "native".to_owned();
   1635         public.source_repository = None;
   1636         public.source_revision = None;
   1637         public.source_path = None;
   1638         public.source_tree_sha256 = None;
   1639         public.introduction_tree_sha256 = Some("a".repeat(64));
   1640         assert!(validate_package_provenance(public).is_err());
   1641     }
   1642 
   1643     #[test]
   1644     fn native_provenance_matches_staged_then_derived_introduction_tree() {
   1645         let root = git_fixture();
   1646         let package_root = root.path().join("crates/native_fixture");
   1647         fs::create_dir_all(&package_root).expect("native package root");
   1648         fs::write(
   1649             package_root.join("Cargo.toml"),
   1650             "[package]\nname='fixture'\n",
   1651         )
   1652         .expect("native manifest");
   1653         fs::write(package_root.join("lib.rs"), "pub fn initial() {}\n").expect("native source");
   1654         git(root.path(), &["add", "crates/native_fixture"]);
   1655 
   1656         let staged =
   1657             staged_tree_digest(root.path(), "crates/native_fixture").expect("staged tree digest");
   1658         assert_eq!(
   1659             native_introducing_commit(root.path(), "crates/native_fixture")
   1660                 .expect("precommit history"),
   1661             None
   1662         );
   1663         let mut catalog = checked_in_catalog();
   1664         let package = native_package(&mut catalog, "crates/native_fixture", &staged);
   1665         validate_native_source_provenance(package, root.path()).expect("staged provenance");
   1666 
   1667         fs::write(package_root.join("lib.rs"), "unstaged change\n").expect("unstaged change");
   1668         validate_native_source_provenance(package, root.path())
   1669             .expect("only the staged introduction is authoritative before commit");
   1670         git(
   1671             root.path(),
   1672             &["commit", "--quiet", "-m", "add native package"],
   1673         );
   1674 
   1675         let introducing = native_introducing_commit(root.path(), "crates/native_fixture")
   1676             .expect("committed history")
   1677             .expect("introducing commit");
   1678         assert_eq!(
   1679             committed_tree_digest(root.path(), &introducing, "crates/native_fixture")
   1680                 .expect("committed introduction digest"),
   1681             staged
   1682         );
   1683         validate_native_source_provenance(package, root.path())
   1684             .expect("derived committed provenance");
   1685 
   1686         git(root.path(), &["add", "crates/native_fixture/lib.rs"]);
   1687         git(
   1688             root.path(),
   1689             &["commit", "--quiet", "-m", "change native package"],
   1690         );
   1691         validate_native_source_provenance(package, root.path())
   1692             .expect("later changes do not rewrite introduction provenance");
   1693         package.introduction_tree_sha256 = Some("b".repeat(64));
   1694         assert!(validate_native_source_provenance(package, root.path()).is_err());
   1695     }
   1696 
   1697     #[test]
   1698     fn native_precommit_provenance_requires_stage_zero_index_records() {
   1699         let root = git_fixture();
   1700         fs::create_dir_all(root.path().join("crates/native_fixture")).expect("native package root");
   1701         fs::write(
   1702             root.path().join("crates/native_fixture/lib.rs"),
   1703             "pub fn unstaged() {}\n",
   1704         )
   1705         .expect("unstaged native source");
   1706         assert!(staged_tree_digest(root.path(), "crates/native_fixture").is_err());
   1707 
   1708         let oid = "a".repeat(40);
   1709         let conflicted = format!("100644 {oid} 1\tcrates/native_fixture/lib.rs\0");
   1710         assert!(canonical_staged_tree_records(conflicted.as_bytes()).is_err());
   1711 
   1712         let intent_to_add = format!(
   1713             "100644 {} 0\tcrates/native_fixture/lib.rs\0",
   1714             "0".repeat(40)
   1715         );
   1716         assert!(canonical_staged_tree_records(intent_to_add.as_bytes()).is_err());
   1717     }
   1718 
   1719     #[test]
   1720     fn generated_maps_are_sorted_and_digest_bound() {
   1721         let mut values = BTreeMap::from([("sdk", vec!["z", "a", "a"])]);
   1722         sort_map_values(&mut values);
   1723         let rendered = render_map_projection("fixture.v1", &"a".repeat(64), "group", &values);
   1724         assert!(rendered.contains("catalog_sha256"));
   1725         assert!(rendered.contains("packages = [\"a\", \"z\"]"));
   1726     }
   1727 
   1728     #[test]
   1729     fn checked_in_catalog_structure_is_valid() {
   1730         validate_catalog(&checked_in_catalog()).expect("catalog structure");
   1731     }
   1732 
   1733     #[test]
   1734     fn retired_application_packages_cannot_return_as_dependencies_or_sources() {
   1735         for name in
   1736             RETIRED_APPLICATION_PACKAGES
   1737                 .into_iter()
   1738                 .chain(["tera", "tera_core", "tera_ffi"])
   1739         {
   1740             assert!(validate_foundation_dependency(name, None).is_err());
   1741         }
   1742         for source in [
   1743             "git+https://github.com/radrootslabs/tera?rev=immutable",
   1744             "https://github.com/radrootslabs/tera.git",
   1745             "ssh://git@github.com/radrootslabs/tera.git",
   1746         ] {
   1747             assert!(validate_foundation_dependency("renamed_application", Some(source)).is_err());
   1748         }
   1749         validate_foundation_dependency("radroots_sdk", None).expect("shared SDK remains owned");
   1750         validate_foundation_dependency("radroots_storage_sqlite", None)
   1751             .expect("shared storage remains owned");
   1752         let catalog = checked_in_catalog();
   1753         validate_application_retirement(&catalog, &crate::workspace_root())
   1754             .expect("retirement is coherent");
   1755         let fixture = tempfile::TempDir::new().expect("retirement fixture");
   1756         let decision = fixture.path().join(APPLICATION_RETIREMENT);
   1757         fs::create_dir_all(decision.parent().expect("decision parent"))
   1758             .expect("decision directory");
   1759         fs::copy(
   1760             crate::workspace_root().join(APPLICATION_RETIREMENT),
   1761             &decision,
   1762         )
   1763         .expect("decision");
   1764         validate_application_retirement(&catalog, fixture.path()).expect("no application source");
   1765         fs::create_dir_all(fixture.path().join("crates/mobile_core")).expect("reintroduced source");
   1766         assert!(validate_application_retirement(&catalog, fixture.path()).is_err());
   1767     }
   1768 
   1769     #[test]
   1770     fn retirement_rejects_missing_duplicate_or_modified_package_evidence() {
   1771         let fixture = tempfile::TempDir::new().expect("retirement fixture");
   1772         let path = fixture.path().join(APPLICATION_RETIREMENT);
   1773         fs::create_dir_all(path.parent().expect("parent")).expect("decision directory");
   1774         let original: serde_json::Value = serde_json::from_slice(
   1775             &fs::read(crate::workspace_root().join(APPLICATION_RETIREMENT)).expect("decision"),
   1776         )
   1777         .expect("decision JSON");
   1778         let catalog = checked_in_catalog();
   1779         for case in 0..5 {
   1780             let mut changed = original.clone();
   1781             match case {
   1782                 0 => {
   1783                     changed["package"].as_array_mut().expect("packages").pop();
   1784                 }
   1785                 1 => {
   1786                     changed["package"][1] = changed["package"][0].clone();
   1787                 }
   1788                 2 => {
   1789                     changed["package"][0]["former_catalog_entry"]["license"] = "MIT".into();
   1790                 }
   1791                 3 => {
   1792                     changed["package"][0]["target_path"] = "../outside".into();
   1793                 }
   1794                 _ => {
   1795                     changed["unknown"] = true.into();
   1796                 }
   1797             }
   1798             fs::write(&path, serde_json::to_vec(&changed).expect("encode"))
   1799                 .expect("altered decision");
   1800             assert!(validate_application_retirement(&catalog, fixture.path()).is_err());
   1801         }
   1802         let mut reactivated = checked_in_catalog();
   1803         reactivated
   1804             .retired_packages
   1805             .retain(|name| name != "radroots_mobile_core");
   1806         assert!(validate_catalog(&reactivated).is_err());
   1807     }
   1808 
   1809     #[test]
   1810     fn catalog_rejects_obsolete_and_floating_compiler_minimum() {
   1811         let mut catalog = checked_in_catalog();
   1812         catalog.rust_version = "1.99.0".to_owned();
   1813         validate_catalog(&catalog).expect("exact current compiler minimum");
   1814         for minimum in ["1.97.1", "1.98.0", "stable", "1.100.0"] {
   1815             catalog.rust_version = minimum.to_owned();
   1816             assert!(validate_catalog(&catalog).is_err(), "accepted {minimum}");
   1817         }
   1818     }
   1819 
   1820     #[test]
   1821     fn catalog_rejects_version_visibility_license_and_retirement_drift() {
   1822         let mut catalog = checked_in_catalog();
   1823         catalog
   1824             .package
   1825             .iter_mut()
   1826             .find(|package| package.name == "xtask")
   1827             .expect("xtask")
   1828             .publish = true;
   1829         assert!(validate_catalog(&catalog).is_err());
   1830 
   1831         let mut catalog = checked_in_catalog();
   1832         catalog
   1833             .package
   1834             .iter_mut()
   1835             .find(|package| package.name == "radroots_core")
   1836             .expect("core")
   1837             .license = "GPL-3.0-only".to_owned();
   1838         assert!(validate_catalog(&catalog).is_err());
   1839 
   1840         let mut catalog = checked_in_catalog();
   1841         catalog
   1842             .package
   1843             .iter_mut()
   1844             .find(|package| package.name == "radroots_sdk_ffi")
   1845             .expect("sdk ffi")
   1846             .version = "0.1.0-alpha.1".to_owned();
   1847         assert!(validate_catalog(&catalog).is_err());
   1848 
   1849         let mut catalog = checked_in_catalog();
   1850         catalog.retired_packages.push("radroots_core".to_owned());
   1851         assert!(validate_catalog(&catalog).is_err());
   1852     }
   1853 
   1854     #[test]
   1855     fn catalog_rejects_naming_path_and_package_count_drift() {
   1856         let mut catalog = checked_in_catalog();
   1857         catalog.package_count -= 1;
   1858         assert!(validate_catalog(&catalog).is_err());
   1859 
   1860         let mut catalog = checked_in_catalog();
   1861         catalog.package[0].name = "radroots-bad-name".to_owned();
   1862         assert!(validate_catalog(&catalog).is_err());
   1863 
   1864         let mut catalog = checked_in_catalog();
   1865         catalog.package[0].path = "../escape".to_owned();
   1866         assert!(validate_catalog(&catalog).is_err());
   1867     }
   1868 
   1869     #[test]
   1870     fn metadata_rejects_floating_sources_and_tier_edges() {
   1871         let workspace_root = crate::workspace_root();
   1872         let catalog = checked_in_catalog();
   1873         let mut metadata = cargo_metadata(&workspace_root).expect("cargo metadata");
   1874         let dependency = metadata
   1875             .packages
   1876             .iter_mut()
   1877             .find(|package| package.name == "radroots_event")
   1878             .and_then(|package| {
   1879                 package
   1880                     .dependencies
   1881                     .iter_mut()
   1882                     .find(|dependency| dependency.name == "radroots_core")
   1883             })
   1884             .expect("event to core dependency");
   1885         dependency.path = None;
   1886         dependency.req = "*".to_owned();
   1887         assert!(validate_metadata(&catalog, &metadata, &workspace_root).is_err());
   1888 
   1889         let mut catalog = checked_in_catalog();
   1890         catalog
   1891             .package
   1892             .iter_mut()
   1893             .find(|package| package.name == "radroots_event")
   1894             .expect("event")
   1895             .permitted_dependency_tiers
   1896             .retain(|tier| tier != "foundation");
   1897         let metadata = cargo_metadata(&workspace_root).expect("cargo metadata");
   1898         assert!(validate_metadata(&catalog, &metadata, &workspace_root).is_err());
   1899     }
   1900 }