lib

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

main.rs (43759B)


      1 #![cfg_attr(coverage_nightly, feature(coverage_attribute))]
      2 #![forbid(unsafe_code)]
      3 #![recursion_limit = "256"]
      4 
      5 // These release-qualification modules are executable integration boundaries:
      6 // their governed lanes invoke external toolchains, fuzzers, package builds,
      7 // advisory scanners, SBOM generators, and target checks. They are exercised
      8 // by their dedicated release gates and must not recursively execute inside
      9 // xtask's unit-coverage process.
     10 mod advisory_snapshot;
     11 #[cfg_attr(coverage_nightly, coverage(off))]
     12 mod api_qualification;
     13 #[cfg_attr(coverage_nightly, coverage(off))]
     14 mod architecture;
     15 mod artifact_admission;
     16 mod bounded_process;
     17 #[cfg_attr(coverage_nightly, coverage(off))]
     18 mod build_control;
     19 mod build_output;
     20 #[cfg_attr(coverage_nightly, coverage(off))]
     21 mod catalog;
     22 mod compiler_preparation;
     23 #[cfg_attr(coverage_nightly, coverage(off))]
     24 mod consolidation;
     25 #[cfg_attr(coverage_nightly, coverage(off))]
     26 mod contract;
     27 mod coverage;
     28 #[cfg_attr(coverage_nightly, coverage(off))]
     29 mod dto_roots;
     30 mod exact_tree_archive;
     31 #[cfg_attr(coverage_nightly, coverage(off))]
     32 mod fuzz_qualification;
     33 #[cfg_attr(coverage_nightly, coverage(off))]
     34 mod generate;
     35 #[cfg_attr(coverage_nightly, coverage(off))]
     36 mod hygiene;
     37 #[cfg_attr(coverage_nightly, coverage(off))]
     38 mod portable_qualification;
     39 #[cfg_attr(coverage_nightly, coverage(off))]
     40 mod release_graph;
     41 mod release_preflight;
     42 #[cfg_attr(coverage_nightly, coverage(off))]
     43 mod release_qualification;
     44 mod rshr_202_step_298_gate;
     45 mod rshr_202_step_298_platform;
     46 mod rshr_202_step_299_gate;
     47 mod rshr_202_step_304_gate;
     48 mod rshr_202_step_305_gate;
     49 mod rshr_202_step_306_gate;
     50 mod safe_artifact_io;
     51 #[cfg_attr(coverage_nightly, coverage(off))]
     52 mod safety_qualification;
     53 #[cfg_attr(coverage_nightly, coverage(off))]
     54 mod sdk_generation;
     55 mod service_build_qualification;
     56 mod service_release_artifacts;
     57 mod service_repro_install;
     58 mod service_source_lock;
     59 mod service_source_lock_command;
     60 mod service_source_lock_nix;
     61 mod service_source_lock_parts;
     62 #[cfg(test)]
     63 mod service_source_lock_v3;
     64 mod service_source_lock_v4;
     65 mod shared_protocol;
     66 #[cfg_attr(coverage_nightly, coverage(off))]
     67 mod supply_chain_qualification;
     68 #[cfg_attr(coverage_nightly, coverage(off))]
     69 mod target_qualification;
     70 
     71 use clap::{Parser, Subcommand, ValueEnum};
     72 use std::env;
     73 use std::path::{Path, PathBuf};
     74 use std::process::ExitCode;
     75 
     76 #[derive(Debug, Parser)]
     77 #[command(name = "xtask", disable_help_subcommand = true)]
     78 struct Cli {
     79     #[command(subcommand)]
     80     command: XtaskCommand,
     81 }
     82 
     83 #[derive(Debug, Subcommand)]
     84 enum XtaskCommand {
     85     AdvisorySnapshotSelfTest,
     86     #[command(hide = true)]
     87     AdvisorySnapshotFixtureScanner {
     88         #[arg(long, default_value = "report")]
     89         mode: String,
     90     },
     91     Architecture,
     92     ArchitectureCi,
     93     ArchitectureSourceExportCi,
     94     BoundedProcessSelfTest,
     95     SafeArtifactIoSelfTest,
     96     CheckApiBoundaries,
     97     CheckDependencyBoundaries,
     98     Check {
     99         #[arg(long)]
    100         group: String,
    101         #[arg(long, value_enum, default_value_t = GroupOperation::Check)]
    102         operation: GroupOperation,
    103         #[arg(long)]
    104         execute: bool,
    105         #[arg(long)]
    106         include_reserved: bool,
    107     },
    108     Catalog {
    109         #[command(subcommand)]
    110         command: CatalogCommand,
    111     },
    112     #[command(trailing_var_arg = true)]
    113     Contract {
    114         #[arg(allow_hyphen_values = true)]
    115         args: Vec<String>,
    116     },
    117     #[command(trailing_var_arg = true)]
    118     Consolidation {
    119         #[arg(allow_hyphen_values = true)]
    120         args: Vec<String>,
    121     },
    122     #[command(trailing_var_arg = true)]
    123     Coverage {
    124         #[arg(allow_hyphen_values = true)]
    125         args: Vec<String>,
    126     },
    127     #[command(name = "dto-roots", trailing_var_arg = true)]
    128     DtoRoots {
    129         #[arg(allow_hyphen_values = true)]
    130         args: Vec<String>,
    131     },
    132     #[command(trailing_var_arg = true)]
    133     Generate {
    134         #[arg(allow_hyphen_values = true)]
    135         args: Vec<String>,
    136     },
    137     #[command(trailing_var_arg = true)]
    138     Hygiene {
    139         #[arg(allow_hyphen_values = true)]
    140         args: Vec<String>,
    141     },
    142     #[command(trailing_var_arg = true)]
    143     Release {
    144         #[arg(allow_hyphen_values = true)]
    145         args: Vec<String>,
    146     },
    147     #[command(name = "rshr-step-298-gate", hide = true)]
    148     RshrStep298Gate {
    149         #[arg(long)]
    150         step: u16,
    151         #[arg(long)]
    152         check_id: String,
    153         #[arg(long)]
    154         source_revision: String,
    155         #[arg(long)]
    156         source_tree: String,
    157         #[arg(long)]
    158         candidate_digest: String,
    159         #[arg(long)]
    160         platform: String,
    161         #[arg(long)]
    162         execution_request_sha256: String,
    163     },
    164     #[command(name = "rshr-step-298-platform-probe", hide = true)]
    165     RshrStep298PlatformProbe,
    166     #[command(name = "rshr-step-299-gate", hide = true)]
    167     RshrStep299Gate {
    168         #[arg(long)]
    169         step: u16,
    170         #[arg(long)]
    171         check_id: String,
    172         #[arg(long)]
    173         source_revision: String,
    174         #[arg(long)]
    175         source_tree: String,
    176         #[arg(long)]
    177         candidate_digest: String,
    178         #[arg(long)]
    179         platform: String,
    180         #[arg(long)]
    181         execution_request_sha256: String,
    182     },
    183     #[command(name = "rshr-step-304-gate", hide = true)]
    184     RshrStep304Gate {
    185         #[arg(long)]
    186         step: u16,
    187         #[arg(long)]
    188         check_id: String,
    189         #[arg(long)]
    190         source_revision: String,
    191         #[arg(long)]
    192         source_tree: String,
    193         #[arg(long)]
    194         candidate_digest: String,
    195         #[arg(long)]
    196         platform: String,
    197         #[arg(long)]
    198         execution_request_sha256: String,
    199     },
    200     #[command(name = "rshr-step-305-gate", hide = true)]
    201     RshrStep305Gate {
    202         #[arg(long)]
    203         step: u16,
    204         #[arg(long)]
    205         check_id: String,
    206         #[arg(long)]
    207         source_revision: String,
    208         #[arg(long)]
    209         source_tree: String,
    210         #[arg(long)]
    211         candidate_digest: String,
    212         #[arg(long)]
    213         platform: String,
    214         #[arg(long)]
    215         execution_request_sha256: String,
    216     },
    217     #[command(name = "rshr-step-306-gate", hide = true)]
    218     RshrStep306Gate {
    219         #[arg(long)]
    220         step: u16,
    221         #[arg(long)]
    222         check_id: String,
    223         #[arg(long)]
    224         source_revision: String,
    225         #[arg(long)]
    226         source_tree: String,
    227         #[arg(long)]
    228         candidate_digest: String,
    229         #[arg(long)]
    230         platform: String,
    231         #[arg(long)]
    232         execution_request_sha256: String,
    233     },
    234     SourceLock {
    235         #[arg(long)]
    236         consumer_root: PathBuf,
    237     },
    238     ServiceSourceLock {
    239         #[arg(long, value_enum)]
    240         mode: ServiceSourceLockMode,
    241         #[arg(long)]
    242         service_root: PathBuf,
    243         #[arg(long)]
    244         source_archive: PathBuf,
    245     },
    246     ServiceReleaseArtifacts {
    247         #[arg(long, value_enum)]
    248         mode: ServiceReleaseArtifactMode,
    249         #[arg(long)]
    250         service_root: PathBuf,
    251         #[arg(long)]
    252         lib_root: PathBuf,
    253         #[arg(long)]
    254         input_root: PathBuf,
    255         #[arg(long)]
    256         output_root: PathBuf,
    257         #[arg(long)]
    258         target: String,
    259         #[arg(long)]
    260         source_date_epoch: u32,
    261         #[arg(long)]
    262         candidate_digest: String,
    263     },
    264     ServiceReproInstall {
    265         #[arg(long)]
    266         plan: PathBuf,
    267         #[arg(long)]
    268         source_root: PathBuf,
    269         #[arg(long)]
    270         root_preimage_root: PathBuf,
    271         #[arg(long)]
    272         predecessor_artifact_root: PathBuf,
    273         #[arg(long)]
    274         git_executable: PathBuf,
    275         #[arg(long)]
    276         adapter_executable: PathBuf,
    277         #[arg(long)]
    278         output: PathBuf,
    279     },
    280     Source {
    281         #[command(subcommand)]
    282         command: SourceCommand,
    283     },
    284     Artifact {
    285         #[arg(long, value_enum)]
    286         product: ArtifactProduct,
    287         #[arg(long, value_enum)]
    288         target: ArtifactTarget,
    289         #[arg(long, value_enum)]
    290         language: ArtifactLanguage,
    291         #[arg(long, value_enum)]
    292         mode: ArtifactMode,
    293         #[arg(long)]
    294         consumer_root: PathBuf,
    295         #[arg(long)]
    296         source_root: PathBuf,
    297         #[arg(long)]
    298         output: PathBuf,
    299         #[arg(long)]
    300         source_date_epoch: u64,
    301         #[arg(long)]
    302         builder_id: String,
    303         #[arg(long, value_delimiter = ',')]
    304         features: Vec<String>,
    305     },
    306 }
    307 
    308 #[derive(Clone, Copy, Debug, Subcommand)]
    309 enum CatalogCommand {
    310     Check,
    311     Write,
    312 }
    313 
    314 #[derive(Clone, Copy, Debug, ValueEnum)]
    315 enum GroupOperation {
    316     Check,
    317     Test,
    318     Clippy,
    319 }
    320 
    321 #[derive(Clone, Copy, Debug, ValueEnum)]
    322 enum ArtifactMode {
    323     Check,
    324     Write,
    325 }
    326 
    327 #[derive(Clone, Copy, Debug, ValueEnum)]
    328 enum SourceMode {
    329     Prefetch,
    330     Offline,
    331 }
    332 
    333 #[derive(Clone, Copy, Debug, ValueEnum)]
    334 enum ServiceSourceLockMode {
    335     Check,
    336     Write,
    337     Prepare,
    338 }
    339 
    340 #[derive(Clone, Copy, Debug, ValueEnum)]
    341 enum ServiceReleaseArtifactMode {
    342     Check,
    343     Write,
    344 }
    345 
    346 #[derive(Clone, Copy, Debug, ValueEnum)]
    347 enum ArtifactProduct {
    348     Sdk,
    349 }
    350 
    351 impl ArtifactProduct {
    352     fn as_str(self) -> &'static str {
    353         match self {
    354             Self::Sdk => "sdk",
    355         }
    356     }
    357 }
    358 
    359 #[derive(Clone, Copy, Debug, ValueEnum)]
    360 enum ArtifactTarget {
    361     Typescript,
    362     Wasm,
    363     Ffi,
    364     Linux,
    365     Macos,
    366     Windows,
    367 }
    368 
    369 impl ArtifactTarget {
    370     fn as_str(self) -> &'static str {
    371         match self {
    372             Self::Typescript => "typescript",
    373             Self::Wasm => "wasm",
    374             Self::Ffi => "ffi",
    375             Self::Linux => "linux",
    376             Self::Macos => "macos",
    377             Self::Windows => "windows",
    378         }
    379     }
    380 }
    381 
    382 #[derive(Clone, Copy, Debug, ValueEnum)]
    383 enum ArtifactLanguage {
    384     Typescript,
    385     Swift,
    386     Kotlin,
    387     Javascript,
    388 }
    389 
    390 impl ArtifactLanguage {
    391     fn as_str(self) -> &'static str {
    392         match self {
    393             Self::Typescript => "typescript",
    394             Self::Swift => "swift",
    395             Self::Kotlin => "kotlin",
    396             Self::Javascript => "javascript",
    397         }
    398     }
    399 }
    400 
    401 #[derive(Debug, Subcommand)]
    402 enum SourceCommand {
    403     Materialize {
    404         #[arg(long)]
    405         consumer_root: PathBuf,
    406         #[arg(long)]
    407         cache_root: PathBuf,
    408         #[arg(long, value_enum)]
    409         mode: SourceMode,
    410     },
    411     ArchiveVerify {
    412         #[arg(long)]
    413         archive: PathBuf,
    414         #[arg(long)]
    415         sha256: String,
    416     },
    417     ArchiveCreate {
    418         #[arg(long)]
    419         source_root: PathBuf,
    420         #[arg(long)]
    421         revision: String,
    422         #[arg(long)]
    423         output: PathBuf,
    424     },
    425 }
    426 
    427 fn usage() {
    428     eprintln!("usage:");
    429     eprintln!("  cargo xtask architecture");
    430     eprintln!("  cargo xtask architecture-ci");
    431     eprintln!("  cargo xtask architecture-source-export-ci");
    432     eprintln!("  cargo xtask advisory-snapshot-self-test");
    433     eprintln!("  cargo xtask bounded-process-self-test");
    434     eprintln!("  cargo xtask safe-artifact-io-self-test");
    435     eprintln!("  cargo xtask check-api-boundaries");
    436     eprintln!("  cargo xtask check-dependency-boundaries");
    437     eprintln!("  cargo xtask check --group <group> [--operation check|test|clippy] [--execute]");
    438     eprintln!("  cargo xtask catalog check|write");
    439     eprintln!("  cargo xtask contract validate");
    440     eprintln!("  cargo xtask contract event-contract-registry-v7 [--write]");
    441     eprintln!("  cargo xtask contract knowledge-manifest [--write]");
    442     eprintln!("  cargo xtask consolidation baseline");
    443     eprintln!("  cargo xtask consolidation history [--archive-root <absolute-directory>]");
    444     eprintln!("  cargo xtask consolidation history-rehearsal");
    445     eprintln!(
    446         "  cargo xtask consolidation import-verify --source <id> --source-root <absolute-directory> --filtered-root <absolute-directory> --mode <check|write>"
    447     );
    448     eprintln!("  cargo xtask dto-roots --check|--write");
    449     eprintln!("  cargo xtask generate protocol --check|--write");
    450     eprintln!("  cargo xtask release preflight");
    451     eprintln!("  cargo xtask release qualify-features");
    452     eprintln!("  cargo xtask release qualify-graph");
    453     eprintln!("  cargo xtask release qualify-api");
    454     eprintln!("  cargo xtask release qualify-fuzz");
    455     eprintln!("  cargo xtask release qualify-portable");
    456     eprintln!("  cargo xtask release qualify-safety");
    457     eprintln!("  cargo xtask release qualify-supply-chain");
    458     eprintln!("  cargo xtask release qualify-targets");
    459     eprintln!("  cargo xtask coverage run-crate --crate <crate> [--out <dir>]");
    460     eprintln!("  cargo xtask coverage required-crates");
    461     eprintln!("  cargo xtask coverage workspace-crates");
    462     eprintln!(
    463         "  cargo xtask coverage report --scope <scope> --summary <file> --lcov <file> --out <file> [--policy-gate | (--fail-under-exec-lines <pct> --fail-under-functions <pct> --fail-under-regions <pct> --fail-under-branches <pct> [--require-branches])]"
    464     );
    465     eprintln!(
    466         "  cargo xtask coverage report-missing --scope <scope> --out <file> --reason <reason>"
    467     );
    468     eprintln!(
    469         "  cargo xtask coverage refresh-summary [--reports-root <dir>] [--out <file>] [--status-out <file>]"
    470     );
    471     eprintln!("  cargo xtask hygiene forbidden-identifiers");
    472     eprintln!(
    473         "  cargo xtask hygiene prototype-contracts [--config <repo-relative-path>] [--strict|--report-only]"
    474     );
    475     eprintln!("  cargo xtask source-lock --consumer-root <absolute-directory>");
    476     eprintln!(
    477         "  cargo xtask service-source-lock --mode <check|write|prepare> --service-root <absolute-directory> --source-archive <absolute-bundle>"
    478     );
    479     eprintln!(
    480         "  cargo xtask service-release-artifacts --mode <check|write> --service-root <absolute-directory> --lib-root <absolute-directory> --input-root <absolute-directory> --output-root <absolute-directory> --target <rust-target> --source-date-epoch <seconds> --candidate-digest <sha256>"
    481     );
    482     eprintln!(
    483         "  cargo xtask service-repro-install --plan <absolute-file> --source-root <absolute-directory> --root-preimage-root <absolute-directory> --predecessor-artifact-root <absolute-directory> --git-executable <absolute-file> --adapter-executable <absolute-file> --output <absolute-file>"
    484     );
    485     eprintln!(
    486         "  cargo xtask source materialize --consumer-root <absolute-directory> --cache-root <absolute-directory> --mode <prefetch|offline>"
    487     );
    488     eprintln!("  cargo xtask source archive-verify --archive <bundle> --sha256 <digest>");
    489     eprintln!(
    490         "  cargo xtask source archive-create --source-root <absolute-directory> --revision <full-sha> --output <absolute-bundle>"
    491     );
    492     eprintln!(
    493         "  cargo xtask artifact --product sdk --target <target> --language <language> --mode <check|write> --consumer-root <absolute-directory> --source-root <absolute-directory> --output <relative-path> --source-date-epoch <seconds> --builder-id <id>"
    494     );
    495 }
    496 
    497 fn workspace_root_with_override(override_root: Option<&str>) -> PathBuf {
    498     if let Some(raw) = override_root {
    499         let trimmed = raw.trim();
    500         if !trimmed.is_empty() {
    501             return PathBuf::from(trimmed);
    502         }
    503     }
    504     let manifest_dir = Path::new(env!("CARGO_MANIFEST_DIR"));
    505     let crates_dir = manifest_dir.parent().unwrap_or(manifest_dir);
    506     let root = crates_dir.parent().unwrap_or(crates_dir);
    507     root.to_path_buf()
    508 }
    509 
    510 fn workspace_root() -> PathBuf {
    511     let override_root = env::var("RADROOTS_WORKSPACE_ROOT").ok();
    512     workspace_root_with_override(override_root.as_deref())
    513 }
    514 
    515 fn validate_protocol_contracts() -> Result<(), String> {
    516     use radroots_protocol::{capability, event, runtime, schema};
    517 
    518     capability::v1::validate_catalog(capability::v1::CATALOG).map_err(|error| error.to_string())?;
    519     event::v1::validate_catalog(event::v1::CATALOG).map_err(|error| error.to_string())?;
    520     event::v1::validate_trade_state_vocabulary(event::v1::TRADE_STATE_VOCABULARY)
    521         .map_err(|error| error.to_string())?;
    522     runtime::v1::validate_catalog(runtime::v1::CATALOG).map_err(|error| error.to_string())?;
    523     schema::protocol_v1_registry()
    524         .map(|_| ())
    525         .map_err(|error| error.to_string())
    526 }
    527 
    528 fn validate_contract() -> Result<(), String> {
    529     validate_protocol_contracts()?;
    530     let root = workspace_root();
    531     artifact_admission::validate_contract(&root)?;
    532     service_source_lock::validate_contract(&root)?;
    533     // Retain historical qualification integrity separately from current requirements.
    534     service_build_qualification::validate_contract(&root)?;
    535     compiler_preparation::validate_contract(&root)?;
    536     shared_protocol::validate_contract(&root)?;
    537     service_release_artifacts::validate_contract(&root)?;
    538     service_repro_install::validate_contract(&root)?;
    539     dto_roots::check(&root)?;
    540     generate::protocol::check(&root)?;
    541     generate::data_notices::run("--check", &root)?;
    542     contract::load_contract_bundle(&root)
    543         .and_then(|bundle| contract::validate_contract_bundle(&bundle))
    544         .and_then(|_| contract::validate_canonical_event_boundary(&root))
    545         .and_then(|_| contract::validate_artifact_contracts(&root))
    546 }
    547 
    548 #[cfg_attr(coverage_nightly, coverage(off))]
    549 fn release_preflight() -> Result<(), String> {
    550     let root = workspace_root();
    551     release_preflight_at(&root)
    552 }
    553 
    554 fn release_preflight_at(root: &Path) -> Result<(), String> {
    555     use release_preflight::{LaneId, LaneState};
    556 
    557     release_preflight::execute_all(|lane| {
    558         let result = match lane {
    559             LaneId::Catalog => catalog::check(root),
    560             LaneId::ServiceSourceLockContract => service_source_lock::validate_contract(root),
    561             LaneId::ServiceBuildQualificationContract => {
    562                 service_build_qualification::validate_contract(root)
    563                     .and_then(|()| compiler_preparation::validate_contract(root))
    564             }
    565             LaneId::ServiceReleaseArtifactsContract => {
    566                 service_release_artifacts::validate_contract(root)
    567                     .and_then(|()| service_repro_install::validate_contract(root))
    568             }
    569             LaneId::PublicNativeGroup => build_control::group_plan(
    570                 root,
    571                 "public_native",
    572                 build_control::Operation::Check,
    573                 false,
    574             )
    575             .map(|_| ()),
    576             LaneId::PreviewGroup => {
    577                 build_control::group_plan(root, "preview", build_control::Operation::Check, false)
    578                     .map(|_| ())
    579             }
    580             LaneId::ToolsGroup => {
    581                 build_control::group_plan(root, "tools", build_control::Operation::Check, false)
    582                     .map(|_| ())
    583             }
    584             LaneId::DtoRoots => dto_roots::check(root),
    585             LaneId::ProtocolFreshness => generate::protocol::check(root),
    586             LaneId::ArtifactContracts => contract::validate_artifact_contracts(root),
    587             LaneId::ReleaseContracts => advisory_snapshot::validate_decision(root)
    588                 .and_then(|_| contract::validate_release_preflight(root)),
    589         };
    590         match result {
    591             Ok(()) => LaneState::Pass,
    592             Err(error) => {
    593                 eprintln!("release preflight {} failed: {error}", lane.as_str());
    594                 LaneState::Failed
    595             }
    596         }
    597     })
    598     .map(|_| ())
    599     .map_err(|error| error.to_string())
    600 }
    601 
    602 #[cfg_attr(coverage_nightly, coverage(off))]
    603 fn run_release(args: &[String]) -> Result<(), String> {
    604     match args.first().map(String::as_str) {
    605         Some("preflight") => release_preflight(),
    606         Some("qualify-features") => release_qualification::run_feature_matrix(&workspace_root()),
    607         Some("qualify-graph") => release_graph::run(&workspace_root()),
    608         Some("qualify-api") => api_qualification::run(&workspace_root()),
    609         Some("qualify-fuzz") => fuzz_qualification::run(&workspace_root()),
    610         Some("qualify-portable") => portable_qualification::run(&workspace_root()),
    611         Some("qualify-safety") => safety_qualification::run(&workspace_root()),
    612         Some("qualify-supply-chain") => supply_chain_qualification::run(&workspace_root()),
    613         Some("qualify-targets") => target_qualification::run(&workspace_root()),
    614         _ => Err("unknown release subcommand".to_string()),
    615     }
    616 }
    617 
    618 #[cfg_attr(coverage_nightly, coverage(off))]
    619 fn run_contract(args: &[String]) -> Result<(), String> {
    620     match args.first().map(String::as_str) {
    621         Some("validate") => validate_contract(),
    622         Some("event-contract-registry-v7") => match &args[1..] {
    623             [] => contract::validate_event_contract_registry_v7_inventory(&workspace_root()),
    624             [flag] if flag == "--write" => {
    625                 contract::write_event_contract_registry_v7_inventory(&workspace_root())
    626             }
    627             _ => Err(
    628                 "event-contract-registry-v7 accepts no arguments or exactly --write".to_string(),
    629             ),
    630         },
    631         Some("knowledge-manifest") => {
    632             if args.get(1).map(String::as_str) == Some("--write") {
    633                 contract::write_knowledge_contract_manifest(&workspace_root())
    634             } else {
    635                 contract::validate_knowledge_contract_manifest(&workspace_root())
    636             }
    637         }
    638         _ => Err("unknown contract subcommand".to_string()),
    639     }
    640 }
    641 
    642 fn run(args: &[String]) -> Result<(), String> {
    643     let cli = Cli::try_parse_from(std::iter::once("xtask").chain(args.iter().map(String::as_str)))
    644         .map_err(|error| error.to_string())?;
    645     match cli.command {
    646         XtaskCommand::AdvisorySnapshotSelfTest => advisory_snapshot::self_test(),
    647         XtaskCommand::AdvisorySnapshotFixtureScanner { mode } => {
    648             advisory_snapshot::write_fixture_scanner_output(&mode)
    649         }
    650         XtaskCommand::Architecture => architecture::validate(&workspace_root()),
    651         XtaskCommand::ArchitectureCi => {
    652             catalog::check(&workspace_root())?;
    653             architecture::validate_ci(&workspace_root())?;
    654             validate_contract()
    655         }
    656         XtaskCommand::ArchitectureSourceExportCi => {
    657             catalog::check_source_export(&workspace_root())?;
    658             architecture::validate_ci(&workspace_root())?;
    659             validate_contract()
    660         }
    661         XtaskCommand::BoundedProcessSelfTest => bounded_process::self_test(),
    662         XtaskCommand::SafeArtifactIoSelfTest => {
    663             safe_artifact_io::self_test()?;
    664             release_preflight::self_test()?;
    665             println!("safe artifact I/O self-test: ok");
    666             Ok(())
    667         }
    668         XtaskCommand::CheckApiBoundaries => {
    669             architecture::validate_api_boundaries(&workspace_root())
    670         }
    671         XtaskCommand::CheckDependencyBoundaries => {
    672             architecture::validate_dependency_boundaries(&workspace_root())
    673         }
    674         XtaskCommand::Check {
    675             group,
    676             operation,
    677             execute,
    678             include_reserved,
    679         } => {
    680             let operation = match operation {
    681                 GroupOperation::Check => build_control::Operation::Check,
    682                 GroupOperation::Test => build_control::Operation::Test,
    683                 GroupOperation::Clippy => build_control::Operation::Clippy,
    684             };
    685             let root = workspace_root();
    686             let plan = build_control::group_plan(&root, &group, operation, include_reserved)?;
    687             if execute {
    688                 build_control::execute_group_plan(&root, &plan)
    689             } else {
    690                 build_control::print_plan(&plan);
    691                 Ok(())
    692             }
    693         }
    694         XtaskCommand::Catalog { command } => match command {
    695             CatalogCommand::Check => catalog::run(&["check".to_owned()], &workspace_root()),
    696             CatalogCommand::Write => catalog::run(&["write".to_owned()], &workspace_root()),
    697         },
    698         XtaskCommand::Contract { args } => run_contract(&args),
    699         XtaskCommand::Consolidation { args } => consolidation::run(&args, &workspace_root()),
    700         XtaskCommand::Coverage { args } => coverage::run(&args),
    701         XtaskCommand::DtoRoots { args } => dto_roots::run(&args, &workspace_root()),
    702         XtaskCommand::Generate { args } => generate::run(&args, &workspace_root()),
    703         XtaskCommand::Hygiene { args } => hygiene::run(&args, &workspace_root()),
    704         XtaskCommand::Release { args } => run_release(&args),
    705         XtaskCommand::RshrStep298Gate {
    706             step,
    707             check_id,
    708             source_revision,
    709             source_tree,
    710             candidate_digest,
    711             platform,
    712             execution_request_sha256,
    713         } => rshr_202_step_298_gate::run(rshr_202_step_298_gate::Arguments {
    714             step,
    715             check_id,
    716             source_revision,
    717             source_tree,
    718             candidate_digest,
    719             platform,
    720             execution_request_sha256,
    721         }),
    722         XtaskCommand::RshrStep298PlatformProbe => rshr_202_step_298_platform::run(),
    723         XtaskCommand::RshrStep299Gate {
    724             step,
    725             check_id,
    726             source_revision,
    727             source_tree,
    728             candidate_digest,
    729             platform,
    730             execution_request_sha256,
    731         } => rshr_202_step_299_gate::run(rshr_202_step_299_gate::Arguments {
    732             step,
    733             check_id,
    734             source_revision,
    735             source_tree,
    736             candidate_digest,
    737             platform,
    738             execution_request_sha256,
    739         }),
    740         XtaskCommand::RshrStep304Gate {
    741             step,
    742             check_id,
    743             source_revision,
    744             source_tree,
    745             candidate_digest,
    746             platform,
    747             execution_request_sha256,
    748         } => rshr_202_step_304_gate::run(rshr_202_step_304_gate::Arguments {
    749             step,
    750             check_id,
    751             source_revision,
    752             source_tree,
    753             candidate_digest,
    754             platform,
    755             execution_request_sha256,
    756         }),
    757         XtaskCommand::RshrStep305Gate {
    758             step,
    759             check_id,
    760             source_revision,
    761             source_tree,
    762             candidate_digest,
    763             platform,
    764             execution_request_sha256,
    765         } => rshr_202_step_305_gate::run(rshr_202_step_305_gate::Arguments {
    766             step,
    767             check_id,
    768             source_revision,
    769             source_tree,
    770             candidate_digest,
    771             platform,
    772             execution_request_sha256,
    773         }),
    774         XtaskCommand::RshrStep306Gate {
    775             step,
    776             check_id,
    777             source_revision,
    778             source_tree,
    779             candidate_digest,
    780             platform,
    781             execution_request_sha256,
    782         } => rshr_202_step_306_gate::run(rshr_202_step_306_gate::Arguments {
    783             step,
    784             check_id,
    785             source_revision,
    786             source_tree,
    787             candidate_digest,
    788             platform,
    789             execution_request_sha256,
    790         }),
    791         XtaskCommand::SourceLock { consumer_root } => {
    792             build_control::validate_consumer(&consumer_root).map(|_| ())
    793         }
    794         XtaskCommand::ServiceSourceLock {
    795             mode,
    796             service_root,
    797             source_archive,
    798         } => service_source_lock_command::run(
    799             match mode {
    800                 ServiceSourceLockMode::Check => service_source_lock_command::CommandMode::Check,
    801                 ServiceSourceLockMode::Write => service_source_lock_command::CommandMode::Write,
    802                 ServiceSourceLockMode::Prepare => service_source_lock_command::CommandMode::Prepare,
    803             },
    804             &service_root,
    805             &source_archive,
    806         ),
    807         XtaskCommand::ServiceReleaseArtifacts {
    808             mode,
    809             service_root,
    810             lib_root,
    811             input_root,
    812             output_root,
    813             target,
    814             source_date_epoch,
    815             candidate_digest,
    816         } => service_release_artifacts::run(service_release_artifacts::Arguments {
    817             mode: match mode {
    818                 ServiceReleaseArtifactMode::Check => service_release_artifacts::CommandMode::Check,
    819                 ServiceReleaseArtifactMode::Write => service_release_artifacts::CommandMode::Write,
    820             },
    821             service_root: &service_root,
    822             lib_root: &lib_root,
    823             input_root: &input_root,
    824             output_root: &output_root,
    825             target: &target,
    826             source_date_epoch,
    827             candidate_digest: &candidate_digest,
    828         }),
    829         XtaskCommand::ServiceReproInstall {
    830             plan,
    831             source_root,
    832             root_preimage_root,
    833             predecessor_artifact_root,
    834             git_executable,
    835             adapter_executable,
    836             output,
    837         } => service_repro_install::run(
    838             &workspace_root(),
    839             service_repro_install::Arguments {
    840                 plan: &plan,
    841                 source_root: &source_root,
    842                 root_preimage_root: &root_preimage_root,
    843                 predecessor_artifact_root: &predecessor_artifact_root,
    844                 git_executable: &git_executable,
    845                 adapter_executable: &adapter_executable,
    846                 output: &output,
    847             },
    848         ),
    849         XtaskCommand::Source { command } => match command {
    850             SourceCommand::Materialize {
    851                 consumer_root,
    852                 cache_root,
    853                 mode,
    854             } => build_control::materialize(
    855                 &consumer_root,
    856                 &cache_root,
    857                 matches!(mode, SourceMode::Offline),
    858             )
    859             .map(|path| {
    860                 println!("{}", path.display());
    861             }),
    862             SourceCommand::ArchiveVerify { archive, sha256 } => {
    863                 build_control::verify_source_archive(&archive, &sha256)
    864             }
    865             SourceCommand::ArchiveCreate {
    866                 source_root,
    867                 revision,
    868                 output,
    869             } => build_control::create_source_archive(&source_root, &revision, &output).map(
    870                 |digest| {
    871                     println!("{digest}");
    872                 },
    873             ),
    874         },
    875         XtaskCommand::Artifact {
    876             product,
    877             target,
    878             language,
    879             mode,
    880             consumer_root,
    881             source_root,
    882             output,
    883             source_date_epoch,
    884             builder_id,
    885             features,
    886         } => {
    887             let product = product.as_str();
    888             let target = target.as_str();
    889             let language = language.as_str();
    890             let mode = match mode {
    891                 ArtifactMode::Check => build_control::Mode::Check,
    892                 ArtifactMode::Write => build_control::Mode::Write,
    893             };
    894             build_control::validate_generation_roots(
    895                 product,
    896                 target,
    897                 language,
    898                 &consumer_root,
    899                 &source_root,
    900             )?;
    901             if product == "sdk" {
    902                 sdk_generation::artifact(&source_root, &consumer_root, target, language, mode)?;
    903             }
    904             build_control::artifact(
    905                 product,
    906                 target,
    907                 language,
    908                 mode,
    909                 &consumer_root,
    910                 &source_root,
    911                 &output,
    912                 source_date_epoch,
    913                 &builder_id,
    914                 &features,
    915             )
    916         }
    917     }
    918 }
    919 
    920 fn main_with_args(args: Vec<String>) -> ExitCode {
    921     if args.is_empty() {
    922         usage();
    923         return ExitCode::from(2);
    924     }
    925     match run(&args) {
    926         Ok(()) => ExitCode::SUCCESS,
    927         Err(err) => {
    928             eprintln!("{err}");
    929             usage();
    930             ExitCode::from(2)
    931         }
    932     }
    933 }
    934 
    935 #[cfg_attr(coverage_nightly, coverage(off))]
    936 fn main() -> ExitCode {
    937     main_with_args(env::args().skip(1).collect())
    938 }
    939 
    940 #[cfg(test)]
    941 mod tests {
    942     use super::*;
    943     use std::fs;
    944     use std::sync::{Mutex, MutexGuard, OnceLock};
    945     use std::time::{SystemTime, UNIX_EPOCH};
    946 
    947     fn workspace_lock() -> &'static Mutex<()> {
    948         static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
    949         LOCK.get_or_init(|| Mutex::new(()))
    950     }
    951 
    952     fn lock_workspace() -> MutexGuard<'static, ()> {
    953         match workspace_lock().lock() {
    954             Ok(guard) => guard,
    955             Err(poison) => poison.into_inner(),
    956         }
    957     }
    958 
    959     fn unique_temp_dir(prefix: &str) -> PathBuf {
    960         let ns = SystemTime::now()
    961             .duration_since(UNIX_EPOCH)
    962             .expect("system time")
    963             .as_nanos();
    964         std::env::temp_dir().join(format!("radroots_xtask_main_{prefix}_{ns}"))
    965     }
    966 
    967     #[test]
    968     fn workspace_root_resolves() {
    969         let root = workspace_root();
    970         assert!(root.join("Cargo.toml").exists());
    971     }
    972 
    973     #[test]
    974     fn workspace_root_override_takes_precedence() {
    975         let root = workspace_root_with_override(Some("/tmp/radroots-test-root"));
    976         assert_eq!(root, PathBuf::from("/tmp/radroots-test-root"));
    977 
    978         let fallback = workspace_root_with_override(Some("   "));
    979         assert!(fallback.join("Cargo.toml").exists());
    980 
    981         let default_root = workspace_root_with_override(None);
    982         assert!(default_root.join("Cargo.toml").exists());
    983     }
    984 
    985     #[test]
    986     fn typed_build_control_cli_requires_explicit_modes_and_known_values() {
    987         assert!(Cli::try_parse_from(["xtask", "bounded-process-self-test"]).is_ok());
    988         assert!(Cli::try_parse_from(["xtask", "safe-artifact-io-self-test"]).is_ok());
    989 
    990         let source_args = [
    991             "xtask",
    992             "source",
    993             "materialize",
    994             "--consumer-root",
    995             "/tmp/consumer",
    996             "--cache-root",
    997             "/tmp/cache",
    998         ];
    999         assert!(Cli::try_parse_from(source_args).is_err());
   1000         assert!(Cli::try_parse_from(source_args.into_iter().chain(["--mode", "prefetch"])).is_ok());
   1001 
   1002         assert!(
   1003             Cli::try_parse_from([
   1004                 "xtask",
   1005                 "service-source-lock",
   1006                 "--mode",
   1007                 "check",
   1008                 "--service-root",
   1009                 "/tmp/service",
   1010             ])
   1011             .is_err()
   1012         );
   1013         for mode in ["write", "prepare"] {
   1014             assert!(
   1015                 Cli::try_parse_from([
   1016                     "xtask",
   1017                     "service-source-lock",
   1018                     "--mode",
   1019                     mode,
   1020                     "--service-root",
   1021                     "/tmp/service",
   1022                     "--source-archive",
   1023                     "/tmp/lib.bundle",
   1024                 ])
   1025                 .is_ok()
   1026             );
   1027         }
   1028         assert!(
   1029             Cli::try_parse_from([
   1030                 "xtask",
   1031                 "service-release-artifacts",
   1032                 "--mode",
   1033                 "write",
   1034                 "--service-root",
   1035                 "/tmp/service",
   1036                 "--lib-root",
   1037                 "/tmp/lib",
   1038                 "--input-root",
   1039                 "/tmp/input",
   1040                 "--output-root",
   1041                 "/tmp/output",
   1042                 "--target",
   1043                 "x86_64-unknown-linux-gnu",
   1044             ])
   1045             .is_err()
   1046         );
   1047         assert!(
   1048             Cli::try_parse_from([
   1049                 "xtask",
   1050                 "service-release-artifacts",
   1051                 "--mode",
   1052                 "check",
   1053                 "--service-root",
   1054                 "/tmp/service",
   1055                 "--lib-root",
   1056                 "/tmp/lib",
   1057                 "--input-root",
   1058                 "/tmp/input",
   1059                 "--output-root",
   1060                 "/tmp/output",
   1061                 "--target",
   1062                 "x86_64-unknown-linux-gnu",
   1063                 "--source-date-epoch",
   1064                 "1",
   1065                 "--candidate-digest",
   1066                 "1111111111111111111111111111111111111111111111111111111111111111",
   1067             ])
   1068             .is_ok()
   1069         );
   1070         assert!(
   1071             Cli::try_parse_from([
   1072                 "xtask",
   1073                 "service-repro-install",
   1074                 "--plan",
   1075                 "/tmp/plan.json",
   1076                 "--source-root",
   1077                 "/tmp/source",
   1078                 "--root-preimage-root",
   1079                 "/tmp/root",
   1080                 "--predecessor-artifact-root",
   1081                 "/tmp/predecessor",
   1082                 "--git-executable",
   1083                 "/usr/bin/git",
   1084                 "--adapter-executable",
   1085                 "/tmp/adapter",
   1086                 "--output",
   1087                 "/tmp/result.json",
   1088             ])
   1089             .is_ok()
   1090         );
   1091 
   1092         assert!(
   1093             Cli::try_parse_from([
   1094                 "xtask",
   1095                 "artifact",
   1096                 "--product",
   1097                 "unknown",
   1098                 "--target",
   1099                 "wasm",
   1100                 "--language",
   1101                 "javascript",
   1102                 "--mode",
   1103                 "check",
   1104                 "--consumer-root",
   1105                 "/tmp/consumer",
   1106                 "--source-root",
   1107                 "/tmp/source",
   1108                 "--output",
   1109                 "generated/manifest.json",
   1110                 "--source-date-epoch",
   1111                 "1",
   1112                 "--builder-id",
   1113                 "fixture",
   1114             ])
   1115             .is_err()
   1116         );
   1117     }
   1118 
   1119     #[test]
   1120     fn artifact_cli_values_preserve_every_governed_identifier() {
   1121         assert!(ArtifactProduct::from_str("mobile", false).is_err());
   1122         assert!(ArtifactTarget::from_str("ios", false).is_err());
   1123         assert!(ArtifactTarget::from_str("android", false).is_err());
   1124         assert_eq!([ArtifactProduct::Sdk.as_str()], ["sdk"]);
   1125         assert_eq!(
   1126             [
   1127                 ArtifactTarget::Typescript.as_str(),
   1128                 ArtifactTarget::Wasm.as_str(),
   1129                 ArtifactTarget::Ffi.as_str(),
   1130                 ArtifactTarget::Linux.as_str(),
   1131                 ArtifactTarget::Macos.as_str(),
   1132                 ArtifactTarget::Windows.as_str(),
   1133             ],
   1134             ["typescript", "wasm", "ffi", "linux", "macos", "windows",]
   1135         );
   1136         assert_eq!(
   1137             [
   1138                 ArtifactLanguage::Typescript.as_str(),
   1139                 ArtifactLanguage::Swift.as_str(),
   1140                 ArtifactLanguage::Kotlin.as_str(),
   1141                 ArtifactLanguage::Javascript.as_str(),
   1142             ],
   1143             ["typescript", "swift", "kotlin", "javascript"]
   1144         );
   1145     }
   1146 
   1147     #[test]
   1148     fn run_release_and_dispatchers_cover_error_paths() {
   1149         let unknown_release =
   1150             run_release(&["unknown".to_string()]).expect_err("unknown release subcommand");
   1151         assert!(unknown_release.contains("unknown release subcommand"));
   1152 
   1153         let unknown_contract =
   1154             run_contract(&["unknown".to_string()]).expect_err("unknown contract subcommand");
   1155         assert!(unknown_contract.contains("unknown contract subcommand"));
   1156         let invalid_registry = run_contract(&[
   1157             "event-contract-registry-v7".to_string(),
   1158             "--invalid".to_string(),
   1159         ])
   1160         .expect_err("invalid registry-v7 mode");
   1161         assert!(invalid_registry.contains("exactly --write"));
   1162         let unknown_root = run(&["unknown".to_string()]).expect_err("unknown command");
   1163         assert!(unknown_root.contains("unrecognized subcommand"));
   1164 
   1165         run(&["architecture".to_string()]).expect("architecture ledger validates");
   1166 
   1167         let invalid_dto_roots =
   1168             run(&["dto-roots".to_string()]).expect_err("dto-roots requires an explicit mode");
   1169         assert!(invalid_dto_roots.contains("--check|--write"));
   1170         let invalid_generate =
   1171             run(&["generate".to_string()]).expect_err("generate requires a target and mode");
   1172         assert_eq!(
   1173             invalid_generate,
   1174             "usage: cargo xtask generate protocol|data-notices --check|--write"
   1175         );
   1176 
   1177         let removed_sdk = run(&["sdk".to_string(), "validate".to_string()])
   1178             .expect_err("removed sdk command namespace");
   1179         assert!(removed_sdk.contains("unrecognized subcommand"));
   1180     }
   1181 
   1182     #[test]
   1183     fn release_preflight_exhausts_the_closed_lane_inventory() {
   1184         let workspace = tempfile::TempDir::new().expect("create empty workspace");
   1185         let error = release_preflight_at(workspace.path())
   1186             .expect_err("missing required inputs must fail closed");
   1187         assert_eq!(error, "release preflight required lanes did not all pass");
   1188     }
   1189 
   1190     #[test]
   1191     fn lock_workspace_recovers_from_poisoned_mutex() {
   1192         let handle = std::thread::spawn(|| {
   1193             let _guard = workspace_lock().lock().expect("lock workspace");
   1194             panic!("poison workspace lock");
   1195         });
   1196         assert!(handle.join().is_err());
   1197 
   1198         let _guard = lock_workspace();
   1199     }
   1200 
   1201     #[test]
   1202     fn contract_and_coverage_dispatchers_execute() {
   1203         let _guard = lock_workspace();
   1204         let out_dir = unique_temp_dir("coverage_dispatch");
   1205         fs::create_dir_all(&out_dir).expect("create out dir");
   1206 
   1207         run_contract(&["validate".to_string()]).expect("validate contract");
   1208         run(&["dto-roots".to_string(), "--check".to_string()])
   1209             .expect("validate DTO root freshness");
   1210         run(&[
   1211             "generate".to_string(),
   1212             "protocol".to_string(),
   1213             "--check".to_string(),
   1214         ])
   1215         .expect("validate protocol DTO inventory freshness");
   1216         coverage::run(&["help".to_string()]).expect("coverage help");
   1217         coverage::run(&["required-crates".to_string()]).expect("coverage required crates");
   1218         coverage::run(&["workspace-crates".to_string()]).expect("coverage workspace crates");
   1219 
   1220         let summary_path = out_dir.join("summary.json");
   1221         let lcov_path = out_dir.join("coverage.info");
   1222         let gate_out = out_dir.join("gate-report.json");
   1223         fs::write(
   1224             &summary_path,
   1225             r#"{"data":[{"totals":{"functions":{"percent":100.0},"lines":{"percent":100.0},"regions":{"percent":100.0}}}]}"#,
   1226         )
   1227         .expect("write summary");
   1228         fs::write(&lcov_path, "DA:1,1\nBRDA:1,0,0,1\n").expect("write lcov");
   1229         coverage::run(&[
   1230             "report".to_string(),
   1231             "--scope".to_string(),
   1232             "main-test".to_string(),
   1233             "--summary".to_string(),
   1234             summary_path.display().to_string(),
   1235             "--lcov".to_string(),
   1236             lcov_path.display().to_string(),
   1237             "--out".to_string(),
   1238             gate_out.display().to_string(),
   1239             "--policy-gate".to_string(),
   1240         ])
   1241         .expect("coverage report");
   1242 
   1243         run(&["coverage".to_string(), "help".to_string()]).expect("root run coverage");
   1244         run(&["hygiene".to_string(), "forbidden-identifiers".to_string()])
   1245             .expect("hygiene forbidden identifiers");
   1246         run(&["hygiene".to_string(), "prototype-contracts".to_string()])
   1247             .expect("report prototype contracts");
   1248 
   1249         let _ = fs::remove_dir_all(out_dir);
   1250     }
   1251 
   1252     #[test]
   1253     fn usage_and_main_entrypoints_execute() {
   1254         usage();
   1255         let empty_code = main_with_args(Vec::new());
   1256         assert_eq!(empty_code, ExitCode::from(2));
   1257         let success_code = main_with_args(vec!["coverage".to_string(), "help".to_string()]);
   1258         assert_eq!(success_code, ExitCode::SUCCESS);
   1259         let failure_code = main_with_args(vec!["unknown".to_string()]);
   1260         assert_eq!(failure_code, ExitCode::from(2));
   1261         let _ = main();
   1262     }
   1263 
   1264     #[test]
   1265     fn run_contract_dispatches_validate_command() {
   1266         let _guard = lock_workspace();
   1267         validate_protocol_contracts().expect("final protocol contract catalogs");
   1268         run_contract(&["validate".to_string()]).expect("contract validate");
   1269         run_contract(&["event-contract-registry-v7".to_string()])
   1270             .expect("contract registry-v7 inventory");
   1271         run_contract(&["knowledge-manifest".to_string()]).expect("contract knowledge manifest");
   1272     }
   1273 }