lib

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

architecture.rs (63172B)


      1 use std::{
      2     collections::{BTreeMap, BTreeSet},
      3     fs,
      4     path::{Component, Path},
      5 };
      6 
      7 use serde::Deserialize;
      8 
      9 mod api_leakage;
     10 mod core_contract;
     11 mod decision_package;
     12 mod dependency_boundary;
     13 mod retired_compatibility;
     14 
     15 pub(crate) const STABLE_TOOLCHAIN: &str = "1.99.0";
     16 const FROZEN_V1_MSRV: &str = "1.97.1";
     17 
     18 const DEVIATIONS_RELATIVE: &str = "contracts/architecture/deviations.toml";
     19 const ARCHITECTURE_RELATIVE: &str = "contracts/crates/release_v1/radroots_crates_release_v1.toml";
     20 const ARCHITECTURE_ID: &str = "radroots.crates.release.v1";
     21 const PUBLIC_HOMEPAGE: &str = "https://radroots.org";
     22 const PUBLIC_README: &str = "README.md";
     23 const PUBLIC_AUTHORS: &[&str] = &["Tyson Lupul <tyson@radroots.org>"];
     24 
     25 #[derive(Debug, Deserialize)]
     26 #[serde(deny_unknown_fields)]
     27 struct DeviationLedger {
     28     schema_version: u16,
     29     architecture_id: String,
     30     deviation: Vec<DeviationRecord>,
     31 }
     32 
     33 #[derive(Debug, Deserialize)]
     34 #[serde(deny_unknown_fields)]
     35 struct DeviationRecord {
     36     id: String,
     37     date: String,
     38     status: String,
     39     approval: String,
     40     affected_steps: Vec<String>,
     41     spec_anchors: Vec<String>,
     42     source_evidence: Vec<String>,
     43     replacement_action: String,
     44     verification: Vec<String>,
     45     unresolved_risk: String,
     46     normative_architecture_change: bool,
     47     adr_required: bool,
     48     #[serde(default)]
     49     closure_evidence: Vec<String>,
     50 }
     51 
     52 #[derive(Debug, Deserialize)]
     53 struct ArchitectureIdentity {
     54     spec_id: String,
     55     edition: String,
     56     resolver: String,
     57     rust_version: String,
     58     license: String,
     59     canonical_repositories: Vec<String>,
     60     repositories: BTreeMap<String, ArchitectureRepository>,
     61     package: Vec<ArchitecturePackage>,
     62 }
     63 
     64 #[derive(Debug, Deserialize)]
     65 struct ArchitectureRepository {
     66     url: String,
     67     version: String,
     68     packages: Vec<String>,
     69 }
     70 
     71 #[derive(Debug, Deserialize)]
     72 struct ArchitecturePackage {
     73     name: String,
     74 }
     75 
     76 #[derive(Debug, Deserialize)]
     77 struct ConsolidationOwnership {
     78     canonical_rust_repository: String,
     79 }
     80 
     81 #[derive(Debug, Deserialize)]
     82 struct WorkspaceManifest {
     83     workspace: WorkspaceMembers,
     84 }
     85 
     86 #[derive(Debug, Deserialize)]
     87 struct WorkspaceMembershipManifest {
     88     workspace: WorkspaceMembership,
     89 }
     90 
     91 #[derive(Debug, Deserialize)]
     92 struct WorkspaceMembership {
     93     members: Vec<String>,
     94 }
     95 
     96 #[derive(Debug, Deserialize)]
     97 struct WorkspaceMembers {
     98     members: Vec<String>,
     99     resolver: String,
    100     package: WorkspacePackage,
    101     metadata: WorkspaceMetadata,
    102     lints: WorkspaceLints,
    103 }
    104 
    105 #[derive(Debug, Deserialize)]
    106 struct WorkspaceLints {
    107     rust: WorkspaceRustLints,
    108     rustdoc: WorkspaceRustdocLints,
    109     clippy: WorkspaceClippyLints,
    110 }
    111 
    112 #[derive(Debug, Deserialize)]
    113 struct WorkspaceRustLints {
    114     unsafe_code: String,
    115 }
    116 
    117 #[derive(Debug, Deserialize)]
    118 struct WorkspaceRustdocLints {
    119     broken_intra_doc_links: String,
    120 }
    121 
    122 #[derive(Debug, Deserialize)]
    123 struct WorkspaceClippyLints {
    124     dbg_macro: String,
    125     todo: String,
    126     unimplemented: String,
    127 }
    128 
    129 #[derive(Debug, Deserialize)]
    130 struct WorkspaceMetadata {
    131     radroots: RadrootsWorkspaceMetadata,
    132 }
    133 
    134 #[derive(Debug, Deserialize)]
    135 struct RadrootsWorkspaceMetadata {
    136     #[serde(rename = "public-package")]
    137     public_package: PublicPackageMetadata,
    138 }
    139 
    140 #[derive(Debug, Deserialize)]
    141 struct PublicPackageMetadata {
    142     version: String,
    143     authors: Vec<String>,
    144     readme: String,
    145 }
    146 
    147 #[derive(Debug, Deserialize)]
    148 struct WorkspacePackage {
    149     version: String,
    150     edition: String,
    151     #[serde(rename = "rust-version")]
    152     rust_version: String,
    153     license: String,
    154     repository: String,
    155     homepage: String,
    156     readme: String,
    157     authors: Vec<String>,
    158 }
    159 
    160 pub fn validate(workspace_root: &Path) -> Result<(), String> {
    161     validate_workspace_members(workspace_root)?;
    162     let architecture_path = workspace_root.join(ARCHITECTURE_RELATIVE);
    163     let architecture_raw = fs::read_to_string(&architecture_path)
    164         .map_err(|error| format!("read {}: {error}", architecture_path.display()))?;
    165     let architecture = toml::from_str::<ArchitectureIdentity>(&architecture_raw)
    166         .map_err(|error| format!("parse {}: {error}", architecture_path.display()))?;
    167 
    168     let architecture_packages = public_package_names(workspace_root, &architecture)?;
    169     core_contract::validate(workspace_root)?;
    170     api_leakage::validate_policy_catalog(workspace_root, &architecture_packages)?;
    171     dependency_boundary::validate_policy_catalog(workspace_root, &architecture_packages)?;
    172     retired_compatibility::validate(workspace_root)?;
    173     decision_package::validate(workspace_root)?;
    174     validate_workspace_toolchain(workspace_root, &architecture)?;
    175     validate_public_package_metadata(workspace_root, &architecture)?;
    176     validate_no_production_sibling_paths(workspace_root)?;
    177     validate_public_dependency_versions(workspace_root, &architecture)?;
    178 
    179     let ledger_path = workspace_root.join(DEVIATIONS_RELATIVE);
    180     let ledger_raw = fs::read_to_string(&ledger_path)
    181         .map_err(|error| format!("read {}: {error}", ledger_path.display()))?;
    182     validate_ledger(workspace_root, &architecture.spec_id, &ledger_raw)
    183 }
    184 
    185 pub fn validate_dependency_boundaries(workspace_root: &Path) -> Result<(), String> {
    186     validate(workspace_root)?;
    187     dependency_boundary::validate_resolved_boundaries(workspace_root)
    188 }
    189 
    190 pub fn validate_api_boundaries(workspace_root: &Path) -> Result<(), String> {
    191     validate(workspace_root)?;
    192     api_leakage::validate_public_api(workspace_root)
    193 }
    194 
    195 pub fn validate_ci(workspace_root: &Path) -> Result<(), String> {
    196     validate(workspace_root)?;
    197     dependency_boundary::validate_resolved_boundaries(workspace_root)?;
    198     api_leakage::validate_public_api(workspace_root)
    199 }
    200 
    201 fn validate_workspace_toolchain(
    202     workspace_root: &Path,
    203     architecture: &ArchitectureIdentity,
    204 ) -> Result<(), String> {
    205     let manifest_path = workspace_root.join("Cargo.toml");
    206     let manifest_raw = fs::read_to_string(&manifest_path)
    207         .map_err(|error| format!("read {}: {error}", manifest_path.display()))?;
    208     let manifest = toml::from_str::<WorkspaceManifest>(&manifest_raw)
    209         .map_err(|error| format!("parse {}: {error}", manifest_path.display()))?;
    210     if manifest.workspace.resolver != architecture.resolver || architecture.resolver != "3" {
    211         return Err(format!(
    212             "workspace resolver {} must match architecture resolver {}",
    213             manifest.workspace.resolver, architecture.resolver
    214         ));
    215     }
    216     if architecture.rust_version != FROZEN_V1_MSRV {
    217         return Err("frozen release-v1 compiler identity must remain unchanged".to_owned());
    218     }
    219     if manifest.workspace.package.rust_version != STABLE_TOOLCHAIN {
    220         return Err(format!(
    221             "workspace rust-version {} must match current minimum {STABLE_TOOLCHAIN}",
    222             manifest.workspace.package.rust_version
    223         ));
    224     }
    225     let workspace_package = &manifest.workspace.package;
    226     let public_metadata = &manifest.workspace.metadata.radroots.public_package;
    227     let repository = architecture
    228         .repositories
    229         .values()
    230         .find(|repository| repository.url == workspace_package.repository)
    231         .ok_or_else(|| "workspace repository has no architecture allocation".to_owned())?;
    232     if public_metadata.version != repository.version {
    233         return Err(format!(
    234             "public package version source {} must match repository version {}",
    235             public_metadata.version, repository.version
    236         ));
    237     }
    238     if public_metadata.authors != PUBLIC_AUTHORS {
    239         return Err("public package authors source must match the workspace convention".to_owned());
    240     }
    241     if public_metadata.readme != PUBLIC_README {
    242         return Err(format!(
    243             "public package readme source must be {PUBLIC_README}"
    244         ));
    245     }
    246     let lints = &manifest.workspace.lints;
    247     if lints.rust.unsafe_code != "deny"
    248         || lints.rustdoc.broken_intra_doc_links != "deny"
    249         || lints.clippy.dbg_macro != "deny"
    250         || lints.clippy.todo != "deny"
    251         || lints.clippy.unimplemented != "deny"
    252     {
    253         return Err(
    254             "workspace lints must deny unsafe code and deny the approved rustdoc/Clippy baseline"
    255                 .to_owned(),
    256         );
    257     }
    258     if workspace_package.edition != architecture.edition || architecture.edition != "2024" {
    259         return Err(format!(
    260             "workspace edition {} must match architecture edition {}",
    261             workspace_package.edition, architecture.edition
    262         ));
    263     }
    264     if workspace_package.license != architecture.license {
    265         return Err(format!(
    266             "workspace license {} must match architecture license {}",
    267             workspace_package.license, architecture.license
    268         ));
    269     }
    270     if !architecture
    271         .canonical_repositories
    272         .contains(&workspace_package.repository)
    273     {
    274         return Err(format!(
    275             "workspace repository {} is not canonical",
    276             workspace_package.repository
    277         ));
    278     }
    279     if workspace_package.homepage != PUBLIC_HOMEPAGE {
    280         return Err(format!(
    281             "workspace homepage {} must be {PUBLIC_HOMEPAGE}",
    282             workspace_package.homepage
    283         ));
    284     }
    285     if workspace_package.authors != PUBLIC_AUTHORS {
    286         return Err("workspace authors must match the public package convention".to_owned());
    287     }
    288     if !workspace_root.join(&workspace_package.readme).is_file() {
    289         return Err(format!(
    290             "workspace readme {} does not exist",
    291             workspace_package.readme
    292         ));
    293     }
    294     for license in ["LICENSE-MIT", "LICENSE-APACHE"] {
    295         if !workspace_root.join(license).is_file() {
    296             return Err(format!("workspace is missing {license}"));
    297         }
    298     }
    299     let toolchain_path = workspace_root.join("rust-toolchain.toml");
    300     let toolchain_raw = fs::read_to_string(&toolchain_path)
    301         .map_err(|error| format!("read {}: {error}", toolchain_path.display()))?;
    302     let toolchain = toolchain_raw
    303         .parse::<toml::Value>()
    304         .map_err(|error| format!("parse {}: {error}", toolchain_path.display()))?;
    305     let channel = toolchain
    306         .get("toolchain")
    307         .and_then(|value| value.get("channel"))
    308         .and_then(toml::Value::as_str);
    309     if channel != Some(STABLE_TOOLCHAIN) {
    310         return Err(format!(
    311             "rust-toolchain.toml channel must match current compiler {STABLE_TOOLCHAIN}"
    312         ));
    313     }
    314     Ok(())
    315 }
    316 
    317 fn public_package_names(
    318     workspace_root: &Path,
    319     architecture: &ArchitectureIdentity,
    320 ) -> Result<BTreeSet<String>, String> {
    321     if workspace_root
    322         .join("contracts/crates/catalog.v2.toml")
    323         .is_file()
    324     {
    325         // Current allocation supersedes the frozen V1 inventory. A malformed
    326         // present catalog must fail; only historical fixtures lack this input.
    327         return crate::catalog::public_packages(workspace_root)
    328             .map(|packages| packages.into_iter().collect());
    329     }
    330     Ok(architecture
    331         .package
    332         .iter()
    333         .map(|p| p.name.clone())
    334         .collect())
    335 }
    336 
    337 fn validate_public_package_metadata(
    338     workspace_root: &Path,
    339     architecture: &ArchitectureIdentity,
    340 ) -> Result<(), String> {
    341     let workspace_raw = fs::read_to_string(workspace_root.join("Cargo.toml"))
    342         .map_err(|error| format!("read workspace Cargo.toml: {error}"))?;
    343     let workspace = toml::from_str::<WorkspaceManifest>(&workspace_raw)
    344         .map_err(|error| format!("parse workspace Cargo.toml: {error}"))?;
    345     let repository = architecture
    346         .repositories
    347         .values()
    348         .find(|repository| repository.url == workspace.workspace.package.repository)
    349         .ok_or_else(|| "workspace repository has no architecture allocation".to_owned())?;
    350     let all_packages = public_package_names(workspace_root, architecture)?;
    351     let consolidation_path = workspace_root.join("contracts/consolidation/architecture.v1.toml");
    352     let consolidated_owner = if consolidation_path.is_file() {
    353         let consolidation = fs::read_to_string(&consolidation_path)
    354             .map_err(|error| format!("read {}: {error}", consolidation_path.display()))?;
    355         Some(
    356             toml::from_str::<ConsolidationOwnership>(&consolidation)
    357                 .map_err(|error| format!("parse {}: {error}", consolidation_path.display()))?
    358                 .canonical_rust_repository,
    359         )
    360     } else {
    361         None
    362     };
    363     let local_packages =
    364         if consolidated_owner.as_deref() == Some(workspace.workspace.package.repository.as_str()) {
    365             all_packages.iter().map(|name| (*name).to_owned()).collect()
    366         } else {
    367             repository.packages.iter().cloned().collect::<BTreeSet<_>>()
    368         };
    369     let mut found_local_packages = BTreeSet::new();
    370 
    371     for member in &workspace.workspace.members {
    372         let manifest_path = workspace_root.join(member).join("Cargo.toml");
    373         let raw = fs::read_to_string(&manifest_path)
    374             .map_err(|error| format!("read {}: {error}", manifest_path.display()))?;
    375         let manifest = raw
    376             .parse::<toml::Value>()
    377             .map_err(|error| format!("parse {}: {error}", manifest_path.display()))?;
    378         let package = manifest
    379             .get("package")
    380             .and_then(toml::Value::as_table)
    381             .ok_or_else(|| format!("{} is missing [package]", manifest_path.display()))?;
    382         let name = package
    383             .get("name")
    384             .and_then(toml::Value::as_str)
    385             .ok_or_else(|| format!("{} is missing package.name", manifest_path.display()))?;
    386         if !all_packages.contains(name) {
    387             continue;
    388         }
    389         if !local_packages.contains(name) {
    390             return Err(format!(
    391                 "public package {name} belongs to a different canonical repository"
    392             ));
    393         }
    394         found_local_packages.insert(name.to_owned());
    395         validate_public_manifest_field(
    396             package,
    397             "version",
    398             &workspace.workspace.package.version,
    399             &repository.version,
    400             name,
    401         )?;
    402         validate_public_manifest_field(
    403             package,
    404             "edition",
    405             &workspace.workspace.package.edition,
    406             &architecture.edition,
    407             name,
    408         )?;
    409         validate_public_manifest_field(
    410             package,
    411             "rust-version",
    412             &workspace.workspace.package.rust_version,
    413             STABLE_TOOLCHAIN,
    414             name,
    415         )?;
    416         validate_public_manifest_field(
    417             package,
    418             "license",
    419             &workspace.workspace.package.license,
    420             &architecture.license,
    421             name,
    422         )?;
    423         validate_public_manifest_field(
    424             package,
    425             "repository",
    426             &workspace.workspace.package.repository,
    427             &repository.url,
    428             name,
    429         )?;
    430         validate_public_manifest_field(
    431             package,
    432             "homepage",
    433             &workspace.workspace.package.homepage,
    434             PUBLIC_HOMEPAGE,
    435             name,
    436         )?;
    437         let authors = resolve_public_authors(package, &workspace.workspace.package.authors)
    438             .ok_or_else(|| format!("public package {name} must declare authors"))?;
    439         if authors != PUBLIC_AUTHORS {
    440             return Err(format!(
    441                 "public package {name} authors must match the workspace convention"
    442             ));
    443         }
    444         let readme = package.get("readme").and_then(toml::Value::as_str);
    445         if readme != Some(PUBLIC_README)
    446             || !workspace_root.join(member).join(PUBLIC_README).is_file()
    447         {
    448             return Err(format!(
    449                 "public package {name} must use an existing crate-local {PUBLIC_README}"
    450             ));
    451         }
    452         let publish_registries = package
    453             .get("publish")
    454             .and_then(toml::Value::as_array)
    455             .ok_or_else(|| format!("public package {name} must set publish = [\"crates-io\"]"))?;
    456         if publish_registries.len() != 1 || publish_registries[0].as_str() != Some("crates-io") {
    457             return Err(format!(
    458                 "public package {name} must set publish = [\"crates-io\"]"
    459             ));
    460         }
    461         let inherits_lints = manifest
    462             .get("lints")
    463             .and_then(toml::Value::as_table)
    464             .is_some_and(|lints| {
    465                 lints.len() == 1
    466                     && lints.get("workspace").and_then(toml::Value::as_bool) == Some(true)
    467             });
    468         if !inherits_lints {
    469             return Err(format!(
    470                 "public package {name} must inherit the workspace lint policy"
    471             ));
    472         }
    473     }
    474     if found_local_packages != local_packages {
    475         let missing = local_packages
    476             .difference(&found_local_packages)
    477             .cloned()
    478             .collect::<Vec<_>>()
    479             .join(", ");
    480         let extra = found_local_packages
    481             .difference(&local_packages)
    482             .cloned()
    483             .collect::<Vec<_>>()
    484             .join(", ");
    485         return Err(format!(
    486             "workspace public package inventory is missing: {missing}; workspace public package inventory has unallocated packages: {extra}"
    487         ));
    488     }
    489     Ok(())
    490 }
    491 
    492 fn validate_public_dependency_versions(
    493     workspace_root: &Path,
    494     architecture: &ArchitectureIdentity,
    495 ) -> Result<(), String> {
    496     let workspace_path = workspace_root.join("Cargo.toml");
    497     let workspace_raw = fs::read_to_string(&workspace_path)
    498         .map_err(|error| format!("read {}: {error}", workspace_path.display()))?;
    499     let workspace = toml::from_str::<WorkspaceManifest>(&workspace_raw)
    500         .map_err(|error| format!("parse {}: {error}", workspace_path.display()))?;
    501     let workspace_value = workspace_raw
    502         .parse::<toml::Value>()
    503         .map_err(|error| format!("parse {}: {error}", workspace_path.display()))?;
    504     let workspace_dependencies = workspace_value
    505         .get("workspace")
    506         .and_then(toml::Value::as_table)
    507         .and_then(|workspace| workspace.get("dependencies"))
    508         .and_then(toml::Value::as_table);
    509     let repository = architecture
    510         .repositories
    511         .values()
    512         .find(|repository| repository.url == workspace.workspace.package.repository)
    513         .ok_or_else(|| "workspace repository has no architecture allocation".to_owned())?;
    514     let current_public = public_package_names(workspace_root, architecture)?;
    515     let public_packages = current_public
    516         .iter()
    517         .map(String::as_str)
    518         .collect::<BTreeSet<_>>();
    519     let current_catalog = workspace_root
    520         .join("contracts/crates/catalog.v2.toml")
    521         .is_file();
    522     let local_packages = if current_catalog {
    523         public_packages.clone()
    524     } else {
    525         repository.packages.iter().map(String::as_str).collect()
    526     };
    527     let package_versions = if current_catalog {
    528         public_packages
    529             .iter()
    530             .map(|name| (*name, workspace.workspace.package.version.as_str()))
    531             .collect()
    532     } else {
    533         architecture
    534             .repositories
    535             .values()
    536             .flat_map(|repository| {
    537                 repository
    538                     .packages
    539                     .iter()
    540                     .map(|package| (package.as_str(), repository.version.as_str()))
    541             })
    542             .collect::<BTreeMap<_, _>>()
    543     };
    544 
    545     for member in &workspace.workspace.members {
    546         let manifest_path = workspace_root.join(member).join("Cargo.toml");
    547         let raw = fs::read_to_string(&manifest_path)
    548             .map_err(|error| format!("read {}: {error}", manifest_path.display()))?;
    549         let manifest = raw
    550             .parse::<toml::Value>()
    551             .map_err(|error| format!("parse {}: {error}", manifest_path.display()))?;
    552         let package_name = manifest
    553             .get("package")
    554             .and_then(toml::Value::as_table)
    555             .and_then(|package| package.get("name"))
    556             .and_then(toml::Value::as_str)
    557             .ok_or_else(|| format!("{} is missing package.name", manifest_path.display()))?;
    558         if !local_packages.contains(package_name) {
    559             continue;
    560         }
    561         let policy = PublicDependencyPolicy {
    562             workspace_root,
    563             workspace_dependencies,
    564             public_packages: &public_packages,
    565             local_packages: &local_packages,
    566             package_versions: &package_versions,
    567         };
    568         validate_public_dependency_sections(member, package_name, &manifest, &policy)?;
    569     }
    570     Ok(())
    571 }
    572 
    573 struct PublicDependencyPolicy<'a> {
    574     workspace_root: &'a Path,
    575     workspace_dependencies: Option<&'a toml::value::Table>,
    576     public_packages: &'a BTreeSet<&'a str>,
    577     local_packages: &'a BTreeSet<&'a str>,
    578     package_versions: &'a BTreeMap<&'a str, &'a str>,
    579 }
    580 
    581 fn validate_public_dependency_sections(
    582     member: &str,
    583     owner: &str,
    584     manifest: &toml::Value,
    585     policy: &PublicDependencyPolicy<'_>,
    586 ) -> Result<(), String> {
    587     let manifest_table = manifest
    588         .as_table()
    589         .ok_or_else(|| format!("{member}/Cargo.toml must be a TOML table"))?;
    590     for section in ["dependencies", "dev-dependencies", "build-dependencies"] {
    591         if let Some(dependencies) = manifest_table.get(section).and_then(toml::Value::as_table) {
    592             validate_public_dependency_table(member, owner, section, dependencies, policy)?;
    593         }
    594     }
    595     if let Some(targets) = manifest_table.get("target").and_then(toml::Value::as_table) {
    596         for (target, target_value) in targets {
    597             let Some(target_table) = target_value.as_table() else {
    598                 continue;
    599             };
    600             for section in ["dependencies", "dev-dependencies", "build-dependencies"] {
    601                 if let Some(dependencies) =
    602                     target_table.get(section).and_then(toml::Value::as_table)
    603                 {
    604                     validate_public_dependency_table(
    605                         member,
    606                         owner,
    607                         &format!("target.{target}.{section}"),
    608                         dependencies,
    609                         policy,
    610                     )?;
    611                 }
    612             }
    613         }
    614     }
    615     Ok(())
    616 }
    617 
    618 fn validate_public_dependency_table(
    619     member: &str,
    620     owner: &str,
    621     section: &str,
    622     dependencies: &toml::value::Table,
    623     policy: &PublicDependencyPolicy<'_>,
    624 ) -> Result<(), String> {
    625     for (dependency_key, declaration) in dependencies {
    626         let inherits_workspace = declaration
    627             .as_table()
    628             .and_then(|table| table.get("workspace"))
    629             .and_then(toml::Value::as_bool)
    630             == Some(true);
    631         let resolved = if inherits_workspace {
    632             policy
    633                 .workspace_dependencies
    634                 .and_then(|dependencies| dependencies.get(dependency_key))
    635                 .ok_or_else(|| {
    636                     format!(
    637                         "public package {owner} {section}.{dependency_key} inherits a missing workspace dependency"
    638                     )
    639                 })?
    640         } else {
    641             declaration
    642         };
    643         let resolved_table = resolved.as_table();
    644         let dependency_path = resolved_table
    645             .and_then(|table| table.get("path"))
    646             .and_then(toml::Value::as_str);
    647         let declared_package = resolved_table
    648             .and_then(|table| table.get("package"))
    649             .and_then(toml::Value::as_str);
    650         let path_base = if inherits_workspace {
    651             policy.workspace_root.to_path_buf()
    652         } else {
    653             policy.workspace_root.join(member)
    654         };
    655         let path_package = if declared_package.is_none() {
    656             dependency_path
    657                 .map(|path| dependency_package_name(&path_base.join(path)))
    658                 .transpose()?
    659         } else {
    660             None
    661         };
    662         let dependency_name = declared_package
    663             .or(path_package.as_deref())
    664             .unwrap_or(dependency_key.as_str());
    665         let first_party =
    666             dependency_key.starts_with("radroots_") || dependency_name.starts_with("radroots_");
    667         if first_party && !policy.public_packages.contains(dependency_name) {
    668             return Err(format!(
    669                 "public package {owner} {section}.{dependency_key} must not depend on private first-party package {dependency_name}"
    670             ));
    671         }
    672         if !policy.public_packages.contains(dependency_name) {
    673             continue;
    674         }
    675         let version = match resolved {
    676             toml::Value::String(version) => Some(version.as_str()),
    677             toml::Value::Table(table) => table.get("version").and_then(toml::Value::as_str),
    678             _ => None,
    679         };
    680         let governed_version = policy
    681             .package_versions
    682             .get(dependency_name)
    683             .ok_or_else(|| {
    684                 format!("public dependency {dependency_name} has no repository version authority")
    685             })?;
    686         let exact_version = format!("={governed_version}");
    687         if policy.local_packages.contains(dependency_name)
    688             && (dependency_path.is_none() || version != Some(exact_version.as_str()))
    689         {
    690             return Err(format!(
    691                 "public package {owner} {section}.{dependency_key} dependency on {dependency_name} must declare path and exact version {exact_version}"
    692             ));
    693         }
    694         if !policy.local_packages.contains(dependency_name)
    695             && (dependency_path.is_some() || version != Some(exact_version.as_str()))
    696         {
    697             return Err(format!(
    698                 "public package {owner} {section}.{dependency_key} cross-repository dependency on {dependency_name} must declare exact registry version {exact_version} without a path"
    699             ));
    700         }
    701     }
    702     Ok(())
    703 }
    704 
    705 fn validate_no_production_sibling_paths(workspace_root: &Path) -> Result<(), String> {
    706     let canonical_root = fs::canonicalize(workspace_root)
    707         .map_err(|error| format!("canonicalize {}: {error}", workspace_root.display()))?;
    708     let workspace_path = workspace_root.join("Cargo.toml");
    709     let workspace_raw = fs::read_to_string(&workspace_path)
    710         .map_err(|error| format!("read {}: {error}", workspace_path.display()))?;
    711     let workspace = toml::from_str::<WorkspaceManifest>(&workspace_raw)
    712         .map_err(|error| format!("parse {}: {error}", workspace_path.display()))?;
    713     let workspace_value = workspace_raw
    714         .parse::<toml::Value>()
    715         .map_err(|error| format!("parse {}: {error}", workspace_path.display()))?;
    716     if let Some(dependencies) = workspace_value
    717         .get("workspace")
    718         .and_then(toml::Value::as_table)
    719         .and_then(|workspace| workspace.get("dependencies"))
    720         .and_then(toml::Value::as_table)
    721     {
    722         validate_dependency_path_table(
    723             &canonical_root,
    724             &canonical_root,
    725             "workspace",
    726             "workspace.dependencies",
    727             dependencies,
    728         )?;
    729     }
    730     for member in &workspace.workspace.members {
    731         let manifest_path = workspace_root.join(member).join("Cargo.toml");
    732         let raw = fs::read_to_string(&manifest_path)
    733             .map_err(|error| format!("read {}: {error}", manifest_path.display()))?;
    734         let manifest = raw
    735             .parse::<toml::Value>()
    736             .map_err(|error| format!("parse {}: {error}", manifest_path.display()))?;
    737         validate_manifest_dependency_paths(
    738             &canonical_root,
    739             &canonical_root.join(member),
    740             member,
    741             &manifest,
    742         )?;
    743     }
    744     Ok(())
    745 }
    746 
    747 fn validate_manifest_dependency_paths(
    748     workspace_root: &Path,
    749     package_root: &Path,
    750     owner: &str,
    751     manifest: &toml::Value,
    752 ) -> Result<(), String> {
    753     let Some(manifest_table) = manifest.as_table() else {
    754         return Err(format!("{owner}/Cargo.toml must be a TOML table"));
    755     };
    756     for section in ["dependencies", "dev-dependencies", "build-dependencies"] {
    757         if let Some(dependencies) = manifest_table.get(section).and_then(toml::Value::as_table) {
    758             validate_dependency_path_table(
    759                 workspace_root,
    760                 package_root,
    761                 owner,
    762                 section,
    763                 dependencies,
    764             )?;
    765         }
    766     }
    767     if let Some(targets) = manifest_table.get("target").and_then(toml::Value::as_table) {
    768         for (target, target_value) in targets {
    769             let Some(target_table) = target_value.as_table() else {
    770                 continue;
    771             };
    772             for section in ["dependencies", "dev-dependencies", "build-dependencies"] {
    773                 if let Some(dependencies) =
    774                     target_table.get(section).and_then(toml::Value::as_table)
    775                 {
    776                     validate_dependency_path_table(
    777                         workspace_root,
    778                         package_root,
    779                         owner,
    780                         &format!("target.{target}.{section}"),
    781                         dependencies,
    782                     )?;
    783                 }
    784             }
    785         }
    786     }
    787     Ok(())
    788 }
    789 
    790 fn validate_dependency_path_table(
    791     workspace_root: &Path,
    792     path_base: &Path,
    793     owner: &str,
    794     section: &str,
    795     dependencies: &toml::value::Table,
    796 ) -> Result<(), String> {
    797     for (dependency, declaration) in dependencies {
    798         let Some(path) = declaration
    799             .as_table()
    800             .and_then(|table| table.get("path"))
    801             .and_then(toml::Value::as_str)
    802         else {
    803             continue;
    804         };
    805         let resolved = fs::canonicalize(path_base.join(path)).map_err(|error| {
    806             format!(
    807                 "resolve production dependency {owner} {section}.{dependency} path {path}: {error}"
    808             )
    809         })?;
    810         if !resolved.starts_with(workspace_root) {
    811             return Err(format!(
    812                 "production dependency {owner} {section}.{dependency} path {path} escapes the repository; use a registry version or an external local-development override"
    813             ));
    814         }
    815     }
    816     Ok(())
    817 }
    818 
    819 fn dependency_package_name(package_root: &Path) -> Result<String, String> {
    820     let manifest_path = package_root.join("Cargo.toml");
    821     let raw = fs::read_to_string(&manifest_path).map_err(|error| {
    822         format!(
    823             "read dependency manifest {}: {error}",
    824             manifest_path.display()
    825         )
    826     })?;
    827     let manifest = raw.parse::<toml::Value>().map_err(|error| {
    828         format!(
    829             "parse dependency manifest {}: {error}",
    830             manifest_path.display()
    831         )
    832     })?;
    833     manifest
    834         .get("package")
    835         .and_then(toml::Value::as_table)
    836         .and_then(|package| package.get("name"))
    837         .and_then(toml::Value::as_str)
    838         .map(str::to_owned)
    839         .ok_or_else(|| format!("{} is missing package.name", manifest_path.display()))
    840 }
    841 
    842 fn validate_public_manifest_field(
    843     package: &toml::value::Table,
    844     key: &str,
    845     workspace_value: &str,
    846     expected: &str,
    847     package_name: &str,
    848 ) -> Result<(), String> {
    849     let value = resolve_public_string(package, key, workspace_value)
    850         .ok_or_else(|| format!("public package {package_name} must declare {key}"))?;
    851     if value != expected {
    852         return Err(format!(
    853             "public package {package_name} {key} {value} must be {expected}"
    854         ));
    855     }
    856     Ok(())
    857 }
    858 
    859 fn resolve_public_string<'a>(
    860     package: &'a toml::value::Table,
    861     key: &str,
    862     workspace_value: &'a str,
    863 ) -> Option<&'a str> {
    864     match package.get(key)? {
    865         toml::Value::String(value) => Some(value),
    866         toml::Value::Table(value)
    867             if value.get("workspace").and_then(toml::Value::as_bool) == Some(true) =>
    868         {
    869             Some(workspace_value)
    870         }
    871         _ => None,
    872     }
    873 }
    874 
    875 fn resolve_public_authors<'a>(
    876     package: &'a toml::value::Table,
    877     workspace_authors: &'a [String],
    878 ) -> Option<Vec<&'a str>> {
    879     match package.get("authors")? {
    880         toml::Value::Array(values) => values.iter().map(toml::Value::as_str).collect(),
    881         toml::Value::Table(value)
    882             if value.get("workspace").and_then(toml::Value::as_bool) == Some(true) =>
    883         {
    884             Some(workspace_authors.iter().map(String::as_str).collect())
    885         }
    886         _ => None,
    887     }
    888 }
    889 
    890 fn validate_workspace_members(workspace_root: &Path) -> Result<(), String> {
    891     let manifest_path = workspace_root.join("Cargo.toml");
    892     let manifest_raw = fs::read_to_string(&manifest_path)
    893         .map_err(|error| format!("read {}: {error}", manifest_path.display()))?;
    894     let manifest = toml::from_str::<WorkspaceMembershipManifest>(&manifest_raw)
    895         .map_err(|error| format!("parse {}: {error}", manifest_path.display()))?;
    896     let manifest_value = manifest_raw
    897         .parse::<toml::Value>()
    898         .map_err(|error| format!("parse {}: {error}", manifest_path.display()))?;
    899     validate_manifest_dependency_keys(&manifest_value, "Cargo.toml")?;
    900     let declared = manifest
    901         .workspace
    902         .members
    903         .into_iter()
    904         .collect::<BTreeSet<_>>();
    905     let mut discovered = BTreeSet::new();
    906     for root in ["crates", "tools"] {
    907         let directory = workspace_root.join(root);
    908         for entry in fs::read_dir(&directory)
    909             .map_err(|error| format!("read {}: {error}", directory.display()))?
    910         {
    911             let entry =
    912                 entry.map_err(|error| format!("read {} entry: {error}", directory.display()))?;
    913             if entry
    914                 .file_type()
    915                 .map_err(|error| format!("read {} type: {error}", entry.path().display()))?
    916                 .is_dir()
    917                 && entry.path().join("Cargo.toml").is_file()
    918             {
    919                 let directory_name = entry.file_name().to_string_lossy().into_owned();
    920                 require_lower_snake_case(
    921                     &directory_name,
    922                     &format!("{root}/{directory_name} crate directory"),
    923                 )?;
    924                 let package_manifest_path = entry.path().join("Cargo.toml");
    925                 let package_manifest_raw =
    926                     fs::read_to_string(&package_manifest_path).map_err(|error| {
    927                         format!("read {}: {error}", package_manifest_path.display())
    928                     })?;
    929                 let package_manifest =
    930                     package_manifest_raw
    931                         .parse::<toml::Value>()
    932                         .map_err(|error| {
    933                             format!("parse {}: {error}", package_manifest_path.display())
    934                         })?;
    935                 let package_name = package_manifest
    936                     .get("package")
    937                     .and_then(toml::Value::as_table)
    938                     .and_then(|package| package.get("name"))
    939                     .and_then(toml::Value::as_str)
    940                     .ok_or_else(|| {
    941                         format!(
    942                             "{} is missing package.name",
    943                             package_manifest_path.display()
    944                         )
    945                     })?;
    946                 require_lower_snake_case(
    947                     package_name,
    948                     &format!("{} package.name", package_manifest_path.display()),
    949                 )?;
    950                 validate_manifest_dependency_keys(
    951                     &package_manifest,
    952                     &package_manifest_path.display().to_string(),
    953                 )?;
    954                 discovered.insert(format!("{root}/{directory_name}"));
    955             }
    956         }
    957     }
    958     if declared != discovered {
    959         let missing = discovered
    960             .difference(&declared)
    961             .cloned()
    962             .collect::<Vec<_>>()
    963             .join(", ");
    964         let unknown = declared
    965             .difference(&discovered)
    966             .cloned()
    967             .collect::<Vec<_>>()
    968             .join(", ");
    969         return Err(format!(
    970             "workspace membership is missing local package roots: {missing}; workspace membership has unknown package roots: {unknown}"
    971         ));
    972     }
    973     Ok(())
    974 }
    975 
    976 fn validate_manifest_dependency_keys(manifest: &toml::Value, label: &str) -> Result<(), String> {
    977     let Some(manifest) = manifest.as_table() else {
    978         return Err(format!("{label} must be a TOML table"));
    979     };
    980     for section in ["dependencies", "dev-dependencies", "build-dependencies"] {
    981         if let Some(dependencies) = manifest.get(section).and_then(toml::Value::as_table) {
    982             validate_dependency_keys(dependencies, label, section)?;
    983         }
    984     }
    985     if let Some(workspace_dependencies) = manifest
    986         .get("workspace")
    987         .and_then(toml::Value::as_table)
    988         .and_then(|workspace| workspace.get("dependencies"))
    989         .and_then(toml::Value::as_table)
    990     {
    991         validate_dependency_keys(workspace_dependencies, label, "workspace.dependencies")?;
    992     }
    993     if let Some(targets) = manifest.get("target").and_then(toml::Value::as_table) {
    994         for (target, target_value) in targets {
    995             let Some(target_table) = target_value.as_table() else {
    996                 continue;
    997             };
    998             for section in ["dependencies", "dev-dependencies", "build-dependencies"] {
    999                 if let Some(dependencies) =
   1000                     target_table.get(section).and_then(toml::Value::as_table)
   1001                 {
   1002                     validate_dependency_keys(
   1003                         dependencies,
   1004                         label,
   1005                         &format!("target.{target}.{section}"),
   1006                     )?;
   1007                 }
   1008             }
   1009         }
   1010     }
   1011     Ok(())
   1012 }
   1013 
   1014 fn validate_dependency_keys(
   1015     dependencies: &toml::value::Table,
   1016     label: &str,
   1017     section: &str,
   1018 ) -> Result<(), String> {
   1019     for key in dependencies
   1020         .keys()
   1021         .filter(|key| key.starts_with("radroots"))
   1022     {
   1023         require_lower_snake_case(key, &format!("{label} {section} dependency key"))?;
   1024     }
   1025     Ok(())
   1026 }
   1027 
   1028 fn require_lower_snake_case(value: &str, label: &str) -> Result<(), String> {
   1029     if is_lower_snake_case(value) {
   1030         Ok(())
   1031     } else {
   1032         Err(format!("{label} `{value}` must use lowercase snake case"))
   1033     }
   1034 }
   1035 
   1036 fn is_lower_snake_case(value: &str) -> bool {
   1037     !value.is_empty()
   1038         && value.split('_').all(|segment| {
   1039             segment
   1040                 .as_bytes()
   1041                 .first()
   1042                 .is_some_and(u8::is_ascii_lowercase)
   1043                 && segment
   1044                     .bytes()
   1045                     .all(|byte| byte.is_ascii_lowercase() || byte.is_ascii_digit())
   1046         })
   1047 }
   1048 
   1049 fn validate_ledger(
   1050     workspace_root: &Path,
   1051     expected_architecture_id: &str,
   1052     raw: &str,
   1053 ) -> Result<(), String> {
   1054     let ledger = toml::from_str::<DeviationLedger>(raw)
   1055         .map_err(|error| format!("parse {DEVIATIONS_RELATIVE}: {error}"))?;
   1056     if ledger.schema_version != 1 {
   1057         return Err("deviation ledger schema_version must be 1".to_owned());
   1058     }
   1059     if ledger.architecture_id != expected_architecture_id
   1060         || ledger.architecture_id != ARCHITECTURE_ID
   1061     {
   1062         return Err(format!(
   1063             "deviation ledger architecture_id {} must match {}",
   1064             ledger.architecture_id, expected_architecture_id
   1065         ));
   1066     }
   1067 
   1068     let mut ids = BTreeSet::new();
   1069     for record in &ledger.deviation {
   1070         validate_record(workspace_root, record)?;
   1071         if !ids.insert(record.id.as_str()) {
   1072             return Err(format!("duplicate deviation id {}", record.id));
   1073         }
   1074     }
   1075     Ok(())
   1076 }
   1077 
   1078 fn validate_record(workspace_root: &Path, record: &DeviationRecord) -> Result<(), String> {
   1079     if !is_deviation_id(&record.id) {
   1080         return Err(format!("deviation id {} must use RCRV1-DEV-NNN", record.id));
   1081     }
   1082     if !is_iso_date(&record.date) {
   1083         return Err(format!("deviation {} date must use YYYY-MM-DD", record.id));
   1084     }
   1085     if !matches!(record.status.as_str(), "active" | "closed" | "superseded") {
   1086         return Err(format!(
   1087             "deviation {} status must be active, closed, or superseded",
   1088             record.id
   1089         ));
   1090     }
   1091     require_text(&record.id, "approval", &record.approval)?;
   1092     require_text(&record.id, "replacement_action", &record.replacement_action)?;
   1093     require_text(&record.id, "unresolved_risk", &record.unresolved_risk)?;
   1094     require_nonempty_list(&record.id, "affected_steps", &record.affected_steps)?;
   1095     require_nonempty_list(&record.id, "spec_anchors", &record.spec_anchors)?;
   1096     require_nonempty_list(&record.id, "source_evidence", &record.source_evidence)?;
   1097     require_nonempty_list(&record.id, "verification", &record.verification)?;
   1098 
   1099     for step in &record.affected_steps {
   1100         let valid = step.len() == 3
   1101             && step.bytes().all(|byte| byte.is_ascii_digit())
   1102             && step
   1103                 .parse::<u16>()
   1104                 .is_ok_and(|value| (1..=315).contains(&value));
   1105         if !valid {
   1106             return Err(format!(
   1107                 "deviation {} affected step {} must be in 001..315",
   1108                 record.id, step
   1109             ));
   1110         }
   1111     }
   1112     for anchor in &record.spec_anchors {
   1113         validate_spec_anchor(workspace_root, &record.id, anchor)?;
   1114     }
   1115     if record.status == "active" && !record.closure_evidence.is_empty() {
   1116         return Err(format!(
   1117             "active deviation {} must not carry closure_evidence",
   1118             record.id
   1119         ));
   1120     }
   1121     if record.status != "active" {
   1122         require_nonempty_list(&record.id, "closure_evidence", &record.closure_evidence)?;
   1123     }
   1124 
   1125     let _ = (record.normative_architecture_change, record.adr_required);
   1126     Ok(())
   1127 }
   1128 
   1129 fn validate_spec_anchor(
   1130     workspace_root: &Path,
   1131     deviation_id: &str,
   1132     anchor: &str,
   1133 ) -> Result<(), String> {
   1134     let (relative, fragment) = anchor
   1135         .split_once('#')
   1136         .map_or((anchor, None), |(path, fragment)| (path, Some(fragment)));
   1137     if relative.trim().is_empty() || fragment.is_none_or(|value| value.trim().is_empty()) {
   1138         return Err(format!(
   1139             "deviation {deviation_id} has invalid spec anchor {anchor}"
   1140         ));
   1141     }
   1142     let path = Path::new(relative);
   1143     if path.components().any(|component| {
   1144         matches!(
   1145             component,
   1146             Component::ParentDir | Component::RootDir | Component::Prefix(_)
   1147         )
   1148     }) {
   1149         return Err(format!(
   1150             "deviation {deviation_id} spec anchor must be repository-relative: {anchor}"
   1151         ));
   1152     }
   1153     if relative != ARCHITECTURE_RELATIVE {
   1154         return Err(format!(
   1155             "deviation {deviation_id} spec anchor must target {ARCHITECTURE_RELATIVE}: {anchor}"
   1156         ));
   1157     }
   1158     let machine_path = workspace_root.join(path);
   1159     let raw = fs::read_to_string(&machine_path)
   1160         .map_err(|error| format!("read {}: {error}", machine_path.display()))?;
   1161     let machine = toml::from_str::<toml::Value>(&raw)
   1162         .map_err(|error| format!("parse {}: {error}", machine_path.display()))?;
   1163     let selector = fragment.expect("fragment is required above");
   1164     if !machine_selector_exists(&machine, selector) {
   1165         return Err(format!(
   1166             "deviation {deviation_id} spec anchor has unknown machine selector {selector}"
   1167         ));
   1168     }
   1169     Ok(())
   1170 }
   1171 
   1172 fn machine_selector_exists(machine: &toml::Value, selector: &str) -> bool {
   1173     let segments = selector.split('.').collect::<Vec<_>>();
   1174     if segments.iter().any(|segment| segment.is_empty()) {
   1175         return false;
   1176     }
   1177     let root = match machine.as_table() {
   1178         Some(root) => root,
   1179         None => return false,
   1180     };
   1181     match segments.as_slice() {
   1182         ["repositories", repository] => root
   1183             .get("repositories")
   1184             .and_then(toml::Value::as_table)
   1185             .and_then(|repositories| repositories.get(*repository))
   1186             .is_some_and(toml::Value::is_table),
   1187         ["repository_policy"] | ["release_policy"] => {
   1188             root.get(segments[0]).is_some_and(toml::Value::is_table)
   1189         }
   1190         ["quality_policy", "coverage"] => root
   1191             .get("quality_policy")
   1192             .and_then(toml::Value::as_table)
   1193             .and_then(|quality| quality.get("coverage"))
   1194             .is_some_and(toml::Value::is_table),
   1195         ["package", package] => root
   1196             .get("package")
   1197             .and_then(toml::Value::as_array)
   1198             .is_some_and(|packages| {
   1199                 packages.iter().any(|candidate| {
   1200                     candidate
   1201                         .as_table()
   1202                         .and_then(|table| table.get("name"))
   1203                         .and_then(toml::Value::as_str)
   1204                         == Some(*package)
   1205                 })
   1206             }),
   1207         _ => false,
   1208     }
   1209 }
   1210 
   1211 fn require_text(deviation_id: &str, field: &str, value: &str) -> Result<(), String> {
   1212     if value.trim().is_empty() {
   1213         return Err(format!(
   1214             "deviation {deviation_id} field {field} must not be empty"
   1215         ));
   1216     }
   1217     Ok(())
   1218 }
   1219 
   1220 fn require_nonempty_list(deviation_id: &str, field: &str, values: &[String]) -> Result<(), String> {
   1221     if values.is_empty() || values.iter().any(|value| value.trim().is_empty()) {
   1222         return Err(format!(
   1223             "deviation {deviation_id} field {field} must contain non-empty values"
   1224         ));
   1225     }
   1226     Ok(())
   1227 }
   1228 
   1229 fn is_deviation_id(value: &str) -> bool {
   1230     value
   1231         .strip_prefix("RCRV1-DEV-")
   1232         .is_some_and(|suffix| suffix.len() == 3 && suffix.bytes().all(|byte| byte.is_ascii_digit()))
   1233 }
   1234 
   1235 fn is_iso_date(value: &str) -> bool {
   1236     value.len() == 10
   1237         && value.as_bytes()[4] == b'-'
   1238         && value.as_bytes()[7] == b'-'
   1239         && value
   1240             .bytes()
   1241             .enumerate()
   1242             .all(|(index, byte)| matches!(index, 4 | 7) || byte.is_ascii_digit())
   1243 }
   1244 
   1245 #[cfg(test)]
   1246 mod tests {
   1247     use std::{
   1248         collections::BTreeMap,
   1249         fs,
   1250         path::PathBuf,
   1251         time::{SystemTime, UNIX_EPOCH},
   1252     };
   1253 
   1254     use super::{
   1255         ArchitectureIdentity, ArchitecturePackage, ArchitectureRepository, validate_ledger,
   1256         validate_no_production_sibling_paths, validate_public_dependency_versions,
   1257         validate_public_package_metadata, validate_workspace_members, validate_workspace_toolchain,
   1258     };
   1259 
   1260     fn test_root(label: &str) -> PathBuf {
   1261         let nonce = SystemTime::now()
   1262             .duration_since(UNIX_EPOCH)
   1263             .expect("clock")
   1264             .as_nanos();
   1265         let root = std::env::temp_dir().join(format!("radroots_architecture_{label}_{nonce}"));
   1266         fs::create_dir_all(root.join("contracts/crates/release_v1")).expect("create spec root");
   1267         fs::write(
   1268             root.join("contracts/crates/release_v1/radroots_crates_release_v1.toml"),
   1269             "spec_id = \"radroots.crates.release.v1\"\n\n[repositories.sdk]\nurl = \"https://github.com/radrootslabs/sdk\"\n",
   1270         )
   1271         .expect("write spec");
   1272         root
   1273     }
   1274 
   1275     fn complete_ledger() -> &'static str {
   1276         r#"schema_version = 1
   1277 architecture_id = "radroots.crates.release.v1"
   1278 
   1279 [[deviation]]
   1280 id = "RCRV1-DEV-001"
   1281 date = "2026-07-27"
   1282 status = "active"
   1283 approval = "Explicit user correction dated 2026-07-27."
   1284 affected_steps = ["015", "016"]
   1285 spec_anchors = ["contracts/crates/release_v1/radroots_crates_release_v1.toml#repositories.sdk"]
   1286 source_evidence = ["The approved architecture assigns packages to the existing lib and sdk repositories."]
   1287 replacement_action = "Keep both standalone repositories and verify them independently."
   1288 verification = ["Repository-local architecture validation passes."]
   1289 unresolved_risk = "Remote publication remains separately authorized."
   1290 normative_architecture_change = false
   1291 adr_required = false
   1292 "#
   1293     }
   1294 
   1295     fn architecture() -> ArchitectureIdentity {
   1296         ArchitectureIdentity {
   1297             spec_id: "radroots.crates.release.v1".to_string(),
   1298             edition: "2024".to_string(),
   1299             resolver: "3".to_string(),
   1300             rust_version: "1.97.1".to_string(),
   1301             license: "MIT OR Apache-2.0".to_string(),
   1302             canonical_repositories: vec!["https://github.com/radrootslabs/sdk".to_string()],
   1303             repositories: BTreeMap::from([(
   1304                 "sdk".to_string(),
   1305                 ArchitectureRepository {
   1306                     url: "https://github.com/radrootslabs/sdk".to_string(),
   1307                     version: "0.1.0".to_string(),
   1308                     packages: vec!["radroots".to_string()],
   1309                 },
   1310             )]),
   1311             package: vec![ArchitecturePackage {
   1312                 name: "radroots".to_string(),
   1313             }],
   1314         }
   1315     }
   1316 
   1317     fn complete_workspace_manifest(members: &str) -> String {
   1318         format!(
   1319             "[workspace]\nmembers = [{members}]\nresolver = \"3\"\n\n[workspace.package]\nversion = \"0.1.0\"\nedition = \"2024\"\nrust-version = \"1.99.0\"\nlicense = \"MIT OR Apache-2.0\"\nrepository = \"https://github.com/radrootslabs/sdk\"\nhomepage = \"https://radroots.org\"\nreadme = \"README\"\nauthors = [\"Tyson Lupul <tyson@radroots.org>\"]\n\n[workspace.metadata.radroots.public-package]\nversion = \"0.1.0\"\nauthors = [\"Tyson Lupul <tyson@radroots.org>\"]\nreadme = \"README.md\"\n\n[workspace.lints.rust]\nunsafe_code = \"deny\"\n\n[workspace.lints.rustdoc]\nbroken_intra_doc_links = \"deny\"\n\n[workspace.lints.clippy]\ndbg_macro = \"deny\"\ntodo = \"deny\"\nunimplemented = \"deny\"\n"
   1320         )
   1321     }
   1322 
   1323     #[test]
   1324     fn accepts_complete_active_deviation() {
   1325         let root = test_root("complete");
   1326         validate_ledger(&root, "radroots.crates.release.v1", complete_ledger())
   1327             .expect("complete deviation");
   1328         let _ = fs::remove_dir_all(root);
   1329     }
   1330 
   1331     #[test]
   1332     fn rejects_incomplete_active_deviation() {
   1333         let root = test_root("incomplete");
   1334         let incomplete = complete_ledger().replace(
   1335             "spec_anchors = [\"contracts/crates/release_v1/radroots_crates_release_v1.toml#repositories.sdk\"]",
   1336             "spec_anchors = []",
   1337         );
   1338         let error = validate_ledger(&root, "radroots.crates.release.v1", &incomplete)
   1339             .expect_err("missing anchor must fail");
   1340         assert!(error.contains("field spec_anchors must contain non-empty values"));
   1341         let _ = fs::remove_dir_all(root);
   1342     }
   1343 
   1344     #[test]
   1345     fn deviation_anchors_require_resolving_machine_selectors() {
   1346         let root = test_root("machine_selector");
   1347         let invalid = complete_ledger().replace("#repositories.sdk", "#garbage");
   1348         let error = validate_ledger(&root, "radroots.crates.release.v1", &invalid)
   1349             .expect_err("arbitrary fragment must fail");
   1350         assert!(error.contains("unknown machine selector garbage"));
   1351 
   1352         let markdown_slug =
   1353             complete_ledger().replace("#repositories.sdk", "#20-current-to-target-migration-map");
   1354         let error = validate_ledger(&root, "radroots.crates.release.v1", &markdown_slug)
   1355             .expect_err("Markdown heading slug must fail");
   1356         assert!(error.contains("unknown machine selector"));
   1357         let _ = fs::remove_dir_all(root);
   1358     }
   1359 
   1360     #[test]
   1361     fn workspace_membership_requires_every_local_package_root() {
   1362         let root = test_root("workspace_members");
   1363         for path in ["crates/a", "tools/xtask"] {
   1364             fs::create_dir_all(root.join(path)).expect("create package root");
   1365             fs::write(
   1366                 root.join(path).join("Cargo.toml"),
   1367                 "[package]\nname = \"fixture\"\n",
   1368             )
   1369             .expect("write package manifest");
   1370         }
   1371         fs::write(
   1372             root.join("Cargo.toml"),
   1373             "[workspace]\nmembers = [\"crates/a\", \"tools/xtask\"]\nresolver = \"3\"\n\n[workspace.package]\nrust-version = \"1.99.0\"\n",
   1374         )
   1375         .expect("write complete workspace");
   1376         validate_workspace_members(&root).expect("complete membership");
   1377 
   1378         fs::write(
   1379             root.join("Cargo.toml"),
   1380             "[workspace]\nmembers = [\"tools/xtask\"]\nresolver = \"3\"\n\n[workspace.package]\nrust-version = \"1.99.0\"\n",
   1381         )
   1382         .expect("write incomplete workspace");
   1383         let error = validate_workspace_members(&root).expect_err("missing member must fail");
   1384         assert!(error.contains("missing local package roots: crates/a"));
   1385         let _ = fs::remove_dir_all(root);
   1386     }
   1387 
   1388     #[test]
   1389     fn workspace_identity_rejects_kebab_case_crate_names_and_dependency_keys() {
   1390         let root = test_root("workspace_snake_case_identity");
   1391         fs::create_dir_all(root.join("crates/radroots_probe")).expect("create package root");
   1392         fs::create_dir_all(root.join("tools/xtask")).expect("create xtask root");
   1393         fs::write(
   1394             root.join("Cargo.toml"),
   1395             "[workspace]\nmembers = [\"crates/radroots_probe\", \"tools/xtask\"]\nresolver = \"3\"\n",
   1396         )
   1397         .expect("write workspace manifest");
   1398         fs::write(
   1399             root.join("crates/radroots_probe/Cargo.toml"),
   1400             "[package]\nname = \"radroots-probe\"\n",
   1401         )
   1402         .expect("write kebab package manifest");
   1403         fs::write(
   1404             root.join("tools/xtask/Cargo.toml"),
   1405             "[package]\nname = \"xtask\"\n",
   1406         )
   1407         .expect("write xtask manifest");
   1408 
   1409         let package_error = validate_workspace_members(&root)
   1410             .expect_err("kebab-case Cargo package identity must fail");
   1411         assert!(package_error.contains("package.name"));
   1412         assert!(package_error.contains("lowercase snake case"));
   1413 
   1414         fs::write(
   1415             root.join("crates/radroots_probe/Cargo.toml"),
   1416             "[package]\nname = \"radroots_probe\"\n",
   1417         )
   1418         .expect("write snake package manifest");
   1419         fs::write(
   1420             root.join("Cargo.toml"),
   1421             "[workspace]\nmembers = [\"crates/radroots_probe\", \"tools/xtask\"]\nresolver = \"3\"\n\n[workspace.dependencies]\nradroots-probe = \"0.1.0\"\n",
   1422         )
   1423         .expect("write kebab dependency key");
   1424 
   1425         let dependency_error = validate_workspace_members(&root)
   1426             .expect_err("kebab-case Radroots dependency key must fail");
   1427         assert!(dependency_error.contains("workspace.dependencies dependency key"));
   1428         assert!(dependency_error.contains("lowercase snake case"));
   1429         let _ = fs::remove_dir_all(root);
   1430     }
   1431 
   1432     #[test]
   1433     fn workspace_toolchain_requires_exact_resolver_and_rust_version() {
   1434         let root = test_root("workspace_toolchain");
   1435         fs::write(root.join("Cargo.toml"), complete_workspace_manifest(""))
   1436             .expect("write workspace manifest");
   1437         for path in ["README", "LICENSE-MIT", "LICENSE-APACHE"] {
   1438             fs::write(root.join(path), "fixture\n").expect("write workspace metadata file");
   1439         }
   1440         fs::write(
   1441             root.join("rust-toolchain.toml"),
   1442             "[toolchain]\nchannel = \"1.99.0\"\n",
   1443         )
   1444         .expect("write toolchain");
   1445         let mut architecture = architecture();
   1446         assert_eq!(architecture.rust_version, "1.97.1");
   1447         validate_workspace_toolchain(&root, &architecture).expect("exact current toolchain policy");
   1448 
   1449         for minimum in ["1.97.1", "1.98.0", "stable", "1.100.0"] {
   1450             let manifest = complete_workspace_manifest("").replace("1.99.0", minimum);
   1451             fs::write(root.join("Cargo.toml"), manifest).expect("write wrong current minimum");
   1452             assert!(
   1453                 validate_workspace_toolchain(&root, &architecture).is_err(),
   1454                 "accepted wrong current minimum {minimum}"
   1455             );
   1456         }
   1457         fs::write(root.join("Cargo.toml"), complete_workspace_manifest(""))
   1458             .expect("restore current minimum");
   1459         architecture.rust_version = "1.99.0".to_owned();
   1460         assert!(
   1461             validate_workspace_toolchain(&root, &architecture).is_err(),
   1462             "accepted relabeled frozen release minimum"
   1463         );
   1464         architecture.rust_version = "1.97.1".to_owned();
   1465 
   1466         fs::write(
   1467             root.join("rust-toolchain.toml"),
   1468             "[toolchain]\nchannel = \"1.97.1\"\n",
   1469         )
   1470         .expect("write mismatched toolchain");
   1471         let error = validate_workspace_toolchain(&root, &architecture)
   1472             .expect_err("mismatched toolchain must fail");
   1473         assert!(error.contains("channel must match"));
   1474         let _ = fs::remove_dir_all(root);
   1475     }
   1476 
   1477     #[test]
   1478     fn malformed_current_catalog_never_falls_back_to_frozen_allocation() {
   1479         let root = test_root("malformed_current_catalog");
   1480         fs::create_dir_all(root.join("contracts/crates")).unwrap();
   1481         fs::write(
   1482             root.join("contracts/crates/catalog.v2.toml"),
   1483             "invalid current input",
   1484         )
   1485         .unwrap();
   1486         assert!(super::public_package_names(&root, &architecture()).is_err());
   1487         let _ = fs::remove_dir_all(root);
   1488     }
   1489 
   1490     #[test]
   1491     fn current_allocation_includes_shared_owners_and_rejects_private_packages() {
   1492         let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
   1493             .parent()
   1494             .unwrap()
   1495             .parent()
   1496             .unwrap();
   1497         let names = super::public_package_names(root, &architecture()).unwrap();
   1498         assert_eq!(names.len(), 22);
   1499         assert!(names.contains("radroots_domain") && names.contains("radroots_execution"));
   1500         assert!(!names.contains("radroots_nostrdb"));
   1501     }
   1502 
   1503     #[test]
   1504     fn public_package_metadata_requires_canonical_inheritance() {
   1505         let root = test_root("public_package_metadata");
   1506         fs::create_dir_all(root.join("crates/radroots")).expect("create public package");
   1507         fs::write(
   1508             root.join("Cargo.toml"),
   1509             complete_workspace_manifest("\"crates/radroots\""),
   1510         )
   1511         .expect("write workspace manifest");
   1512         let manifest = "[package]\nname = \"radroots\"\nversion.workspace = true\nedition.workspace = true\nrust-version.workspace = true\nlicense.workspace = true\nrepository.workspace = true\nhomepage.workspace = true\nauthors.workspace = true\nreadme = \"README.md\"\npublish = [\"crates-io\"]\n\n[lints]\nworkspace = true\n";
   1513         fs::write(root.join("crates/radroots/Cargo.toml"), manifest)
   1514             .expect("write public manifest");
   1515         fs::write(root.join("crates/radroots/README.md"), "fixture\n")
   1516             .expect("write public readme");
   1517         validate_public_package_metadata(&root, &architecture()).expect("canonical metadata");
   1518 
   1519         fs::write(
   1520             root.join("crates/radroots/Cargo.toml"),
   1521             manifest.replace("[lints]\nworkspace = true\n", ""),
   1522         )
   1523         .expect("write incomplete public manifest");
   1524         let error = validate_public_package_metadata(&root, &architecture())
   1525             .expect_err("missing lint inheritance must fail");
   1526         assert!(error.contains("must inherit the workspace lint policy"));
   1527         let _ = fs::remove_dir_all(root);
   1528     }
   1529 
   1530     #[test]
   1531     fn public_package_inventory_requires_every_local_package() {
   1532         let root = test_root("public_package_inventory");
   1533         fs::write(root.join("Cargo.toml"), complete_workspace_manifest(""))
   1534             .expect("write workspace manifest");
   1535         let error = validate_public_package_metadata(&root, &architecture())
   1536             .expect_err("missing local public package must fail");
   1537         assert!(error.contains("workspace public package inventory is missing: radroots"));
   1538         let _ = fs::remove_dir_all(root);
   1539     }
   1540 
   1541     #[test]
   1542     fn public_dependencies_require_path_and_exact_version() {
   1543         let root = test_root("public_dependency_version");
   1544         fs::create_dir_all(root.join("crates/radroots")).expect("create public package");
   1545         fs::create_dir_all(root.join("crates/dependency")).expect("create dependency package");
   1546         fs::write(
   1547             root.join("Cargo.toml"),
   1548             format!(
   1549                 "{}\n[workspace.dependencies]\nradroots_core = {{ package = \"radroots_core\", path = \"crates/dependency\", version = \"=0.1.0\" }}\n",
   1550                 complete_workspace_manifest("\"crates/radroots\"")
   1551             ),
   1552         )
   1553         .expect("write workspace manifest");
   1554         fs::write(
   1555             root.join("crates/radroots/Cargo.toml"),
   1556             "[package]\nname = \"radroots\"\nversion = \"0.1.0\"\n\n[dependencies]\nradroots_core = { workspace = true }\n",
   1557         )
   1558         .expect("write public manifest");
   1559         fs::write(
   1560             root.join("crates/dependency/Cargo.toml"),
   1561             "[package]\nname = \"radroots_core\"\nversion = \"0.1.0\"\n",
   1562         )
   1563         .expect("write dependency manifest");
   1564         let mut architecture = architecture();
   1565         architecture.package.push(ArchitecturePackage {
   1566             name: "radroots_core".to_owned(),
   1567         });
   1568         architecture
   1569             .repositories
   1570             .get_mut("sdk")
   1571             .expect("sdk repository")
   1572             .packages
   1573             .push("radroots_core".to_owned());
   1574         validate_public_dependency_versions(&root, &architecture)
   1575             .expect("path plus exact version public dependency");
   1576 
   1577         let workspace_path = root.join("Cargo.toml");
   1578         let workspace = fs::read_to_string(&workspace_path).expect("read workspace manifest");
   1579         fs::write(
   1580             &workspace_path,
   1581             workspace.replace(", version = \"=0.1.0\"", ""),
   1582         )
   1583         .expect("write path-only dependency");
   1584         let error = validate_public_dependency_versions(&root, &architecture)
   1585             .expect_err("path-only public dependency must fail");
   1586         assert!(error.contains("must declare path and exact version =0.1.0"));
   1587         let _ = fs::remove_dir_all(root);
   1588     }
   1589 
   1590     #[test]
   1591     fn production_dependencies_reject_sibling_paths() {
   1592         let root = test_root("production_sibling_path");
   1593         let sibling = root.with_extension("sibling");
   1594         fs::create_dir_all(root.join("crates/radroots")).expect("create public package");
   1595         fs::create_dir_all(root.join("crates/dependency")).expect("create local dependency");
   1596         fs::create_dir_all(&sibling).expect("create sibling dependency");
   1597         fs::write(
   1598             root.join("Cargo.toml"),
   1599             complete_workspace_manifest("\"crates/radroots\""),
   1600         )
   1601         .expect("write workspace manifest");
   1602         let sibling_path = sibling.to_string_lossy();
   1603         fs::write(
   1604             root.join("crates/radroots/Cargo.toml"),
   1605             format!(
   1606                 "[package]\nname = \"radroots\"\nversion = \"0.1.0\"\n\n[dependencies]\nprobe = {{ path = \"{sibling_path}\" }}\n"
   1607             ),
   1608         )
   1609         .expect("write sibling dependency");
   1610         let error = validate_no_production_sibling_paths(&root)
   1611             .expect_err("sibling production path must fail");
   1612         assert!(error.contains("escapes the repository"));
   1613 
   1614         fs::write(
   1615             root.join("crates/radroots/Cargo.toml"),
   1616             "[package]\nname = \"radroots\"\nversion = \"0.1.0\"\n\n[dependencies]\nprobe = { path = \"../dependency\" }\n",
   1617         )
   1618         .expect("write local dependency");
   1619         fs::create_dir_all(root.join(".cargo")).expect("create cargo config directory");
   1620         fs::write(
   1621             root.join(".cargo/config.toml"),
   1622             format!("[patch.crates-io]\nprobe = {{ path = \"{sibling_path}\" }}\n"),
   1623         )
   1624         .expect("write development override");
   1625         validate_no_production_sibling_paths(&root).expect("in-repository path");
   1626         let _ = fs::remove_dir_all(root);
   1627         let _ = fs::remove_dir_all(sibling);
   1628     }
   1629 }