S404 · Scoped authority request publication

#![allow(unexpected_cfgs)]

//! S404 bounded scoped-authority attempt request publication.
//!
//! S403 proves only that CPU0 consumed one valid post-release observation.
//! S404 converts that linear receipt into one CPU1-targeted work request. The
//! request identifies the completed observation and prior exclusive token but
//! deliberately carries no lease or authority. A full slot backpressures
//! before S403 runs, preserving the next S402 observation for retry.
//!
//! CPU1 inspect/take extractors are exposed for a later gate but are not
//! invoked here. No S400 constructor, S244 admission, or S243/S236 path is
//! entered by S404.

use crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s244_whole_scheduler_exclusion_admission_request::{
    S245_SOURCE_CPU0, S245_TARGET_CPU1,
};
use crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s402_provider_invocation_observation_publication::G8lS402ProviderInvocationObservationState;
use crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s403_provider_invocation_observation_consumer::{
    service_s403_model_provider_invocation_observation_consumer,
    G8lS403ProviderInvocationObservationConsumerError,
    G8lS403ProviderInvocationObservationConsumerOutcome,
    G8lS403ProviderInvocationObservationReceipt, S403_DIRECT_SCHEDULER_ACCESS_SITES,
    S403_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES, S403_SOURCE_AUDIT_UNITS,
    S403_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES, S403_UNROUTED_DIRECT_ACCESS_SITES,
};

pub const S404_SOURCE_AUDIT_UNITS: usize = S403_SOURCE_AUDIT_UNITS;
pub const S404_DIRECT_SCHEDULER_ACCESS_SITES: usize = S403_DIRECT_SCHEDULER_ACCESS_SITES;
pub const S404_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES: usize =
    S403_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES;
pub const S404_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES: usize =
    S403_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES;
pub const S404_UNROUTED_DIRECT_ACCESS_SITES: usize = S403_UNROUTED_DIRECT_ACCESS_SITES;
pub const S404_SCOPED_REQUEST_SLOT_CAPACITY: usize = 1;
pub const S404_PRODUCTION_SCOPED_REQUEST_PUBLISHER_CALLSITES: usize = 1;
pub const S404_PRODUCTION_SCOPED_REQUEST_CONSUMER_CALLSITES: usize = 0;
pub const S404_PRODUCTION_ADMISSION_PUBLISHER_SITES: usize = 0;
pub const S404_SCOPED_AUTHORITY_REQUEST_PUBLICATION_COMPLETE: bool = true;
pub const S404_END_TO_END_EXCLUSION_ADMISSION_COMPLETE: bool = false;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS404ScopedAuthorityRequestReason {
    PostReleaseObservationVerified,
}

#[derive(Debug, PartialEq, Eq)]
pub struct G8lS404ScopedAuthorityRequest {
    attempt_id: u64,
    observed_request_id: u64,
    prior_exclusive_token: u64,
    source_cpu: usize,
    target_cpu: usize,
    reason: G8lS404ScopedAuthorityRequestReason,
}

impl G8lS404ScopedAuthorityRequest {
    fn from_s403(receipt: &G8lS403ProviderInvocationObservationReceipt) -> Self {
        Self {
            attempt_id: receipt.request_id(),
            observed_request_id: receipt.request_id(),
            prior_exclusive_token: receipt.exclusive_token(),
            source_cpu: S245_SOURCE_CPU0,
            target_cpu: S245_TARGET_CPU1,
            reason: G8lS404ScopedAuthorityRequestReason::PostReleaseObservationVerified,
        }
    }

    pub const fn attempt_id(&self) -> u64 {
        self.attempt_id
    }

    pub const fn observed_request_id(&self) -> u64 {
        self.observed_request_id
    }

    pub const fn prior_exclusive_token(&self) -> u64 {
        self.prior_exclusive_token
    }

    pub const fn source_cpu(&self) -> usize {
        self.source_cpu
    }

    pub const fn target_cpu(&self) -> usize {
        self.target_cpu
    }

    pub const fn reason(&self) -> G8lS404ScopedAuthorityRequestReason {
        self.reason
    }

    pub const fn is_authority(&self) -> bool {
        false
    }

    pub const fn whole_scheduler_exclusion_proven(&self) -> bool {
        false
    }

    pub const fn view(&self) -> G8lS404ScopedAuthorityRequestView {
        G8lS404ScopedAuthorityRequestView {
            attempt_id: self.attempt_id,
            observed_request_id: self.observed_request_id,
            prior_exclusive_token: self.prior_exclusive_token,
            source_cpu: self.source_cpu,
            target_cpu: self.target_cpu,
            reason: self.reason,
            is_authority: false,
            whole_scheduler_exclusion_proven: false,
        }
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS404ScopedAuthorityRequestView {
    pub attempt_id: u64,
    pub observed_request_id: u64,
    pub prior_exclusive_token: u64,
    pub source_cpu: usize,
    pub target_cpu: usize,
    pub reason: G8lS404ScopedAuthorityRequestReason,
    pub is_authority: bool,
    pub whole_scheduler_exclusion_proven: bool,
}

#[derive(Debug)]
pub struct G8lS404ScopedAuthorityRequestState {
    pending: Option<G8lS404ScopedAuthorityRequest>,
}

impl G8lS404ScopedAuthorityRequestState {
    pub const fn new() -> Self {
        Self { pending: None }
    }

    pub const fn pending(&self) -> bool {
        self.pending.is_some()
    }

    pub fn pending_view(
        &self,
        caller_cpu: usize,
    ) -> Result<Option<G8lS404ScopedAuthorityRequestView>, G8lS404ScopedAuthorityRequestError> {
        if caller_cpu != S245_TARGET_CPU1 {
            return Err(G8lS404ScopedAuthorityRequestError::WrongTargetCpu);
        }
        Ok(self
            .pending
            .as_ref()
            .map(G8lS404ScopedAuthorityRequest::view))
    }

    fn publish(
        &mut self,
        caller_cpu: usize,
        request: G8lS404ScopedAuthorityRequest,
    ) -> Result<G8lS404ScopedAuthorityRequestView, G8lS404ScopedAuthorityRequestError> {
        if caller_cpu != S245_SOURCE_CPU0 {
            return Err(G8lS404ScopedAuthorityRequestError::WrongSourceCpu);
        }
        if self.pending.is_some() {
            return Err(G8lS404ScopedAuthorityRequestError::SlotOccupied);
        }
        let view = request.view();
        self.pending = Some(request);
        Ok(view)
    }

    pub fn take(
        &mut self,
        caller_cpu: usize,
    ) -> Result<Option<G8lS404ScopedAuthorityRequest>, G8lS404ScopedAuthorityRequestError> {
        if caller_cpu != S245_TARGET_CPU1 {
            return Err(G8lS404ScopedAuthorityRequestError::WrongTargetCpu);
        }
        Ok(self.pending.take())
    }
}

impl Default for G8lS404ScopedAuthorityRequestState {
    fn default() -> Self {
        Self::new()
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS404ScopedAuthorityRequestError {
    WrongSourceCpu,
    WrongTargetCpu,
    SlotOccupied,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS404ScopedAuthorityRequestOutcome {
    Idle,
    RequestPublished(G8lS404ScopedAuthorityRequestView),
    RequestPending(G8lS404ScopedAuthorityRequestView),
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS404ScopedAuthorityRequestServiceError {
    WrongProducerCpu,
    S403(G8lS403ProviderInvocationObservationConsumerError),
    State(G8lS404ScopedAuthorityRequestError),
}

pub fn service_s404_model_scoped_authority_request_publication(
    scoped_requests: &mut G8lS404ScopedAuthorityRequestState,
    observations: &mut G8lS402ProviderInvocationObservationState,
    caller_cpu: usize,
) -> Result<G8lS404ScopedAuthorityRequestOutcome, G8lS404ScopedAuthorityRequestServiceError> {
    if caller_cpu != S245_SOURCE_CPU0 {
        return Err(G8lS404ScopedAuthorityRequestServiceError::WrongProducerCpu);
    }
    if let Some(existing) = scoped_requests
        .pending_view(S245_TARGET_CPU1)
        .map_err(G8lS404ScopedAuthorityRequestServiceError::State)?
    {
        return Ok(G8lS404ScopedAuthorityRequestOutcome::RequestPending(
            existing,
        ));
    }
    let consumed =
        service_s403_model_provider_invocation_observation_consumer(observations, caller_cpu)
            .map_err(G8lS404ScopedAuthorityRequestServiceError::S403)?;
    let receipt = match consumed {
        G8lS403ProviderInvocationObservationConsumerOutcome::Idle => {
            return Ok(G8lS404ScopedAuthorityRequestOutcome::Idle)
        }
        G8lS403ProviderInvocationObservationConsumerOutcome::ObservationConsumed(receipt) => {
            receipt
        }
    };
    let request = G8lS404ScopedAuthorityRequest::from_s403(&receipt);
    let view = scoped_requests
        .publish(caller_cpu, request)
        .map_err(G8lS404ScopedAuthorityRequestServiceError::State)?;
    Ok(G8lS404ScopedAuthorityRequestOutcome::RequestPublished(view))
}

#[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
static S404_PRODUCTION_SCOPED_REQUESTS: spin::Mutex<G8lS404ScopedAuthorityRequestState> =
    spin::Mutex::new(G8lS404ScopedAuthorityRequestState::new());

#[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
pub fn service_s404_scoped_authority_request_publication_on_cpu0(
) -> Result<G8lS404ScopedAuthorityRequestOutcome, G8lS404ScopedAuthorityRequestServiceError> {
    use crate::g8l_runtime_contract::{CPU0, CPU1};

    if crate::percpu::try_current_cpu_id() != Some(CPU0) {
        return Err(G8lS404ScopedAuthorityRequestServiceError::WrongProducerCpu);
    }
    if let Some(existing) = S404_PRODUCTION_SCOPED_REQUESTS
        .lock()
        .pending_view(CPU1)
        .map_err(G8lS404ScopedAuthorityRequestServiceError::State)?
    {
        return Ok(G8lS404ScopedAuthorityRequestOutcome::RequestPending(
            existing,
        ));
    }
    let consumed = crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s403_provider_invocation_observation_consumer::service_s403_provider_invocation_observation_consumer_on_cpu0()
        .map_err(G8lS404ScopedAuthorityRequestServiceError::S403)?;
    let receipt = match consumed {
        G8lS403ProviderInvocationObservationConsumerOutcome::Idle => {
            return Ok(G8lS404ScopedAuthorityRequestOutcome::Idle)
        }
        G8lS403ProviderInvocationObservationConsumerOutcome::ObservationConsumed(receipt) => {
            receipt
        }
    };
    let request = G8lS404ScopedAuthorityRequest::from_s403(&receipt);
    let view = S404_PRODUCTION_SCOPED_REQUESTS
        .lock()
        .publish(CPU0, request)
        .map_err(G8lS404ScopedAuthorityRequestServiceError::State)?;
    Ok(G8lS404ScopedAuthorityRequestOutcome::RequestPublished(view))
}

#[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
pub fn inspect_s404_scoped_authority_request_on_cpu1(
) -> Result<Option<G8lS404ScopedAuthorityRequestView>, G8lS404ScopedAuthorityRequestError> {
    use crate::g8l_runtime_contract::CPU1;
    if crate::percpu::try_current_cpu_id() != Some(CPU1) {
        return Err(G8lS404ScopedAuthorityRequestError::WrongTargetCpu);
    }
    S404_PRODUCTION_SCOPED_REQUESTS.lock().pending_view(CPU1)
}

#[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
pub fn take_s404_scoped_authority_request_on_cpu1(
) -> Result<Option<G8lS404ScopedAuthorityRequest>, G8lS404ScopedAuthorityRequestError> {
    use crate::g8l_runtime_contract::CPU1;
    if crate::percpu::try_current_cpu_id() != Some(CPU1) {
        return Err(G8lS404ScopedAuthorityRequestError::WrongTargetCpu);
    }
    S404_PRODUCTION_SCOPED_REQUESTS.lock().take(CPU1)
}

#![recursion_limit = "256"]

use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s244_whole_scheduler_exclusion_admission_request::{
    service_s245_exclusion_admission_request, G8lS245ExclusionAdmissionRequestOutcome,
    G8lS245WholeSchedulerExclusionAdmissionRequestState, S245_SOURCE_CPU0, S245_TARGET_CPU1,
};
use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s246_whole_scheduler_read_access_guard::G8lS247WholeSchedulerAccessGate;
use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s402_provider_invocation_observation_publication::{
    service_s402_model_provider_invocation_observation_publication,
    G8lS402ProviderInvocationObservationState,
};
use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s403_provider_invocation_observation_consumer::{
    S403_DIRECT_SCHEDULER_ACCESS_SITES, S403_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES,
    S403_SOURCE_AUDIT_UNITS, S403_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES,
    S403_UNROUTED_DIRECT_ACCESS_SITES,
};
use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s404_scoped_authority_request_publication::*;

fn observation(
    request_id: u64,
) -> (
    G8lS247WholeSchedulerAccessGate,
    G8lS245WholeSchedulerExclusionAdmissionRequestState,
    G8lS402ProviderInvocationObservationState,
) {
    let gate = G8lS247WholeSchedulerAccessGate::new();
    let mut requests =
        G8lS245WholeSchedulerExclusionAdmissionRequestState::with_next_request_id(request_id);
    assert!(matches!(
        service_s245_exclusion_admission_request(&mut requests, S245_SOURCE_CPU0, true, true),
        Ok(G8lS245ExclusionAdmissionRequestOutcome::RequestPublished(id)) if id == request_id
    ));
    let mut observations = G8lS402ProviderInvocationObservationState::new();
    service_s402_model_provider_invocation_observation_publication(
        &mut observations,
        &gate,
        &mut requests,
        S245_TARGET_CPU1,
    )
    .unwrap();
    (gate, requests, observations)
}

fn module_source() -> &'static str {
    include_str!("../../kernel/src/g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s404_scoped_authority_request_publication.rs")
}

fn exception_source() -> &'static str {
    include_str!("../../kernel/src/arch/aarch64/exceptions.rs")
}

fn kernel_main_source() -> &'static str {
    include_str!("../../kernel/src/main.rs")
}

fn simulation_lib_source() -> &'static str {
    include_str!("../src/lib.rs")
}

#[test]
fn constants_promote_only_one_scoped_authority_request_slot() {
    assert_eq!(S404_SOURCE_AUDIT_UNITS, 7);
    assert_eq!(S404_DIRECT_SCHEDULER_ACCESS_SITES, 113);
    assert_eq!(S404_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES, 113);
    assert_eq!(S404_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES, 113);
    assert_eq!(S404_UNROUTED_DIRECT_ACCESS_SITES, 0);
    assert_eq!(S404_SCOPED_REQUEST_SLOT_CAPACITY, 1);
    assert_eq!(S404_PRODUCTION_SCOPED_REQUEST_PUBLISHER_CALLSITES, 1);
    assert_eq!(S404_PRODUCTION_SCOPED_REQUEST_CONSUMER_CALLSITES, 0);
    assert_eq!(S404_PRODUCTION_ADMISSION_PUBLISHER_SITES, 0);
    assert!(S404_SCOPED_AUTHORITY_REQUEST_PUBLICATION_COMPLETE);
    assert!(!S404_END_TO_END_EXCLUSION_ADMISSION_COMPLETE);
}

#[test]
fn s403_is_the_exact_consumed_observation_predecessor() {
    assert_eq!(S404_SOURCE_AUDIT_UNITS, S403_SOURCE_AUDIT_UNITS);
    assert_eq!(
        S404_DIRECT_SCHEDULER_ACCESS_SITES,
        S403_DIRECT_SCHEDULER_ACCESS_SITES
    );
    assert_eq!(
        S404_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES,
        S403_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES
    );
    assert_eq!(
        S404_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES,
        S403_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES
    );
    assert_eq!(
        S404_UNROUTED_DIRECT_ACCESS_SITES,
        S403_UNROUTED_DIRECT_ACCESS_SITES
    );
}

#[test]
fn consumed_observation_publishes_exact_non_authoritative_scoped_request() {
    let (_gate, _requests, mut observations) = observation(31);
    let mut scoped = G8lS404ScopedAuthorityRequestState::new();
    let outcome = service_s404_model_scoped_authority_request_publication(
        &mut scoped,
        &mut observations,
        S245_SOURCE_CPU0,
    )
    .unwrap();
    let G8lS404ScopedAuthorityRequestOutcome::RequestPublished(view) = outcome else {
        panic!("S403 receipt must publish one scoped request")
    };
    assert_eq!(view.attempt_id, 31);
    assert_eq!(view.observed_request_id, 31);
    assert_eq!(view.prior_exclusive_token, 1);
    assert_eq!(view.source_cpu, S245_SOURCE_CPU0);
    assert_eq!(view.target_cpu, S245_TARGET_CPU1);
    assert_eq!(
        view.reason,
        G8lS404ScopedAuthorityRequestReason::PostReleaseObservationVerified
    );
    assert!(!view.is_authority);
    assert!(!view.whole_scheduler_exclusion_proven);
    assert!(scoped.pending());
    assert!(!observations.pending());
}

#[test]
fn empty_observation_is_idle_and_publishes_nothing() {
    let mut observations = G8lS402ProviderInvocationObservationState::new();
    let mut scoped = G8lS404ScopedAuthorityRequestState::new();
    assert_eq!(
        service_s404_model_scoped_authority_request_publication(
            &mut scoped,
            &mut observations,
            S245_SOURCE_CPU0
        ),
        Ok(G8lS404ScopedAuthorityRequestOutcome::Idle)
    );
    assert!(!scoped.pending());
}

#[test]
fn occupied_scoped_slot_backpressures_before_consuming_next_observation() {
    let (_gate, _requests, mut observations) = observation(1);
    let mut scoped = G8lS404ScopedAuthorityRequestState::new();
    service_s404_model_scoped_authority_request_publication(
        &mut scoped,
        &mut observations,
        S245_SOURCE_CPU0,
    )
    .unwrap();
    let first = scoped.pending_view(S245_TARGET_CPU1).unwrap().unwrap();
    let (_gate2, _requests2, mut next_observations) = observation(2);
    assert_eq!(
        service_s404_model_scoped_authority_request_publication(
            &mut scoped,
            &mut next_observations,
            S245_SOURCE_CPU0,
        ),
        Ok(G8lS404ScopedAuthorityRequestOutcome::RequestPending(first))
    );
    assert_eq!(
        next_observations
            .pending_observation()
            .unwrap()
            .request_id(),
        2
    );
}

#[test]
fn wrong_cpu_preserves_observation_and_scoped_slot() {
    let (_gate, _requests, mut observations) = observation(4);
    let mut scoped = G8lS404ScopedAuthorityRequestState::new();
    assert!(matches!(
        service_s404_model_scoped_authority_request_publication(
            &mut scoped,
            &mut observations,
            S245_TARGET_CPU1
        ),
        Err(G8lS404ScopedAuthorityRequestServiceError::WrongProducerCpu)
    ));
    assert!(observations.pending());
    assert!(!scoped.pending());
}

#[test]
fn request_is_non_copy_non_clone_and_cpu1_take_is_one_shot() {
    let (_gate, _requests, mut observations) = observation(6);
    let mut scoped = G8lS404ScopedAuthorityRequestState::new();
    service_s404_model_scoped_authority_request_publication(
        &mut scoped,
        &mut observations,
        S245_SOURCE_CPU0,
    )
    .unwrap();
    assert!(matches!(
        scoped.take(S245_SOURCE_CPU0),
        Err(G8lS404ScopedAuthorityRequestError::WrongTargetCpu)
    ));
    let request = scoped.take(S245_TARGET_CPU1).unwrap().unwrap();
    assert_eq!(request.attempt_id(), 6);
    assert_eq!(request.observed_request_id(), 6);
    assert_eq!(request.prior_exclusive_token(), 1);
    assert!(!request.is_authority());
    assert!(!request.whole_scheduler_exclusion_proven());
    assert!(scoped.take(S245_TARGET_CPU1).unwrap().is_none());
    let source = module_source();
    let start = source
        .find("pub struct G8lS404ScopedAuthorityRequest")
        .unwrap();
    let derive = source[..start].rfind("#[derive").unwrap();
    assert_eq!(
        source[derive..start].trim(),
        "#[derive(Debug, PartialEq, Eq)]"
    );
}

#[test]
fn model_service_checks_backpressure_before_s403_then_publishes() {
    let source = module_source();
    let start = source
        .find("pub fn service_s404_model_scoped_authority_request_publication")
        .unwrap();
    let function: String = source[start..].split_whitespace().collect();
    let pending = function.find("scoped_requests.pending_view").unwrap();
    let consume = function
        .find("service_s403_model_provider_invocation_observation_consumer")
        .unwrap();
    let publish = function.find("scoped_requests.publish(").unwrap();
    assert!(pending < consume && consume < publish);
}

#[test]
fn production_service_is_the_only_direct_s403_runtime_invoker() {
    assert_eq!(
        module_source()
            .matches("service_s403_provider_invocation_observation_consumer_on_cpu0")
            .count(),
        1
    );
    assert!(!exception_source()
        .contains("service_s403_provider_invocation_observation_consumer_on_cpu0"));
}

#[test]
fn cpu0_timer_chain_invokes_s404_after_s245_and_before_cpu1_services() {
    let source = exception_source();
    let s245 = source
        .find("service_s245_exclusion_admission_request_on_cpu0")
        .unwrap();
    let s404 = source
        .find("service_s404_scoped_authority_request_publication_on_cpu0")
        .unwrap();
    let cpu1 = source[s404..]
        .find("if crate::percpu::current_cpu_id() == 1")
        .map(|offset| offset + s404)
        .unwrap();
    assert!(s245 < s404 && s404 < cpu1);
}

#[test]
fn timer_chain_accepts_idle_published_pending_and_panics_on_error() {
    let source = exception_source();
    for marker in [
        "G8lS404ScopedAuthorityRequestOutcome::Idle",
        "G8lS404ScopedAuthorityRequestOutcome::RequestPublished",
        "G8lS404ScopedAuthorityRequestOutcome::RequestPending",
        "S404 scoped-authority request publication failed closed",
    ] {
        assert!(source.contains(marker), "missing timer marker {marker}");
    }
}

#[test]
fn production_state_exposes_future_cpu1_inspect_and_take_but_invokes_neither() {
    let source = module_source();
    assert!(source.contains("static S404_PRODUCTION_SCOPED_REQUESTS"));
    assert!(source.contains("inspect_s404_scoped_authority_request_on_cpu1"));
    assert!(source.contains("take_s404_scoped_authority_request_on_cpu1"));
    assert_eq!(S404_PRODUCTION_SCOPED_REQUEST_CONSUMER_CALLSITES, 0);
}

#[test]
fn s404_does_not_publish_admission_or_claim_live_exclusion() {
    let source = module_source();
    for forbidden in [
        "publish_s244",
        "service_s243_deferred_authority_receipt_join",
        "try_construct_s400_production_provider_authority_on_cpu1",
        "addr_of!(",
        "addr_of_mut!(",
    ] {
        assert!(
            !source.contains(forbidden),
            "forbidden promotion: {forbidden}"
        );
    }
}

#[test]
fn s404_and_its_exact_s405_preflight_are_registered_separately() {
    let s404 = "g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s404_scoped_authority_request_publication";
    let s405 = "g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s405_scoped_authority_provider_preflight";
    assert!(kernel_main_source().contains(&format!("mod {s404};")));
    assert!(simulation_lib_source().contains(&format!("pub mod {s404};")));
    assert!(kernel_main_source().contains(&format!("mod {s405};")));
    assert!(simulation_lib_source().contains(&format!("pub mod {s405};")));
}

  {
    id: "g8l-s404-scoped-authority-request-publication-partial",
    sequence: 404,
    slug: "scoped_authority_request_publication",
    title: "Scoped authority request publication",
    focusedTests: 14,
    sourceBytes: 11510,
    sourceSha256:
      "41781c36f6e4fe3e3b2963de3c74cf059b7635cd9ff543545bfe51584aa37208",
    testBytes: 11795,
    testSha256:
      "20adaafa7913512899a20bb594d98838b88fe81d5b901159bc046179d9767bf1",
    acceptance:
      "CPU0, consumed S403 receipt'inden exact CPU0→CPU1 reason-bound scoped authority request oluşturup capacity-one slot'a yayımlar.",
    retainedBoundary:
      "Request henüz authority değildir; CPU1 preflight'i request'i tüketmeden S405'te yapılır.",
  },