S410 · Exclusion admission candidate publication

#![allow(unexpected_cfgs)]

//! S410 live-token-revalidated exclusion-admission candidate publication.
//!
//! S409 retains one linear post-EOI SGI3 receipt. S410 rechecks its token
//! against the currently active shared S247 exclusive lease before taking it
//! and publishing one linear CPU0 candidate. The candidate itself is not proof
//! and requires the same gate match again at consumption. S244 remains closed.

use crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s409_live_offer_sgi_delivery::{
    G8lS409LiveOfferSgiDeliveryError, G8lS409LiveOfferSgiDeliveryReceipt,
    G8lS409LiveOfferSgiDeliveryReceiptView, G8lS409LiveOfferSgiDeliveryState,
    S409_DIRECT_SCHEDULER_ACCESS_SITES, S409_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES,
    S409_SOURCE_AUDIT_UNITS, S409_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES,
    S409_UNROUTED_DIRECT_ACCESS_SITES,
};

pub const S410_SOURCE_AUDIT_UNITS: usize = S409_SOURCE_AUDIT_UNITS;
pub const S410_DIRECT_SCHEDULER_ACCESS_SITES: usize = S409_DIRECT_SCHEDULER_ACCESS_SITES;
pub const S410_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES: usize =
    S409_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES;
pub const S410_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES: usize =
    S409_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES;
pub const S410_UNROUTED_DIRECT_ACCESS_SITES: usize = S409_UNROUTED_DIRECT_ACCESS_SITES;
pub const S410_ADMISSION_CANDIDATE_SLOT_CAPACITY: usize = 1;
pub const S410_PRODUCTION_CANDIDATE_PUBLISHER_CALLSITES: usize = 1;
pub const S410_PRODUCTION_S244_ADMISSION_PUBLISHER_SITES: usize = 0;
pub const S410_LIVE_GATE_REVALIDATION_REQUIRED_AT_CONSUMPTION: bool = true;
pub const S410_EXCLUSION_ADMISSION_CANDIDATE_PUBLICATION_COMPLETE: bool = true;
pub const S410_END_TO_END_EXCLUSION_ADMISSION_COMPLETE: bool = false;

#[derive(Debug, PartialEq, Eq)]
pub struct G8lS410ExclusionAdmissionCandidate {
    delivery: G8lS409LiveOfferSgiDeliveryReceipt,
}

impl G8lS410ExclusionAdmissionCandidate {
    fn new(delivery: G8lS409LiveOfferSgiDeliveryReceipt) -> Self {
        Self { delivery }
    }
    pub const fn attempt_id(&self) -> u64 {
        self.delivery.attempt_id()
    }
    pub const fn provider_request_id(&self) -> u64 {
        self.delivery.provider_request_id()
    }
    pub const fn exclusive_token(&self) -> u64 {
        self.delivery.exclusive_token()
    }
    pub const fn requires_live_gate_revalidation(&self) -> bool {
        true
    }
    pub const fn is_authority(&self) -> bool {
        false
    }
    pub const fn whole_scheduler_exclusion_proven(&self) -> bool {
        false
    }
    pub const fn view(&self) -> G8lS410ExclusionAdmissionCandidateView {
        G8lS410ExclusionAdmissionCandidateView {
            attempt_id: self.attempt_id(),
            provider_request_id: self.provider_request_id(),
            exclusive_token: self.exclusive_token(),
            requires_live_gate_revalidation: true,
            is_authority: false,
            whole_scheduler_exclusion_proven: false,
        }
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS410ExclusionAdmissionCandidateView {
    pub attempt_id: u64,
    pub provider_request_id: u64,
    pub exclusive_token: u64,
    pub requires_live_gate_revalidation: bool,
    pub is_authority: bool,
    pub whole_scheduler_exclusion_proven: bool,
}

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

impl G8lS410ExclusionAdmissionCandidateState {
    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<G8lS410ExclusionAdmissionCandidateView>,
        G8lS410ExclusionAdmissionCandidateError,
    > {
        if caller_cpu != 0 {
            return Err(G8lS410ExclusionAdmissionCandidateError::WrongCpu);
        }
        Ok(self
            .pending
            .as_ref()
            .map(G8lS410ExclusionAdmissionCandidate::view))
    }
    fn publish(
        &mut self,
        caller_cpu: usize,
        candidate: G8lS410ExclusionAdmissionCandidate,
    ) -> Result<G8lS410ExclusionAdmissionCandidateView, G8lS410ExclusionAdmissionCandidateError>
    {
        if caller_cpu != 0 {
            return Err(G8lS410ExclusionAdmissionCandidateError::WrongCpu);
        }
        if self.pending.is_some() {
            return Err(G8lS410ExclusionAdmissionCandidateError::SlotOccupied);
        }
        let view = candidate.view();
        self.pending = Some(candidate);
        Ok(view)
    }
    pub fn take(
        &mut self,
        caller_cpu: usize,
    ) -> Result<Option<G8lS410ExclusionAdmissionCandidate>, G8lS410ExclusionAdmissionCandidateError>
    {
        if caller_cpu != 0 {
            return Err(G8lS410ExclusionAdmissionCandidateError::WrongCpu);
        }
        Ok(self.pending.take())
    }
}

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

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS410ExclusionAdmissionCandidateError {
    WrongCpu,
    S409(G8lS409LiveOfferSgiDeliveryError),
    SlotOccupied,
    ReceiptDisappeared,
    ReceiptDrift,
    GateTokenMismatch,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS410ExclusionAdmissionCandidateOutcome {
    Idle,
    CandidatePublished(G8lS410ExclusionAdmissionCandidateView),
    CandidatePending(G8lS410ExclusionAdmissionCandidateView),
}

fn receipt_matches_live_gate(
    receipt: G8lS409LiveOfferSgiDeliveryReceiptView,
    active_exclusive_token: Option<u64>,
) -> bool {
    receipt.raw_ack() == receipt.raw_eoi()
        && receipt.attempt_id() != 0
        && receipt.provider_request_id() != 0
        && receipt.exclusive_token() != 0
        && receipt.gate_token_matched_while_live()
        && active_exclusive_token == Some(receipt.exclusive_token())
}

pub fn service_s410_model_exclusion_admission_candidate_publication(
    candidates: &mut G8lS410ExclusionAdmissionCandidateState,
    delivery: &mut G8lS409LiveOfferSgiDeliveryState,
    caller_cpu: usize,
    active_exclusive_token: Option<u64>,
) -> Result<G8lS410ExclusionAdmissionCandidateOutcome, G8lS410ExclusionAdmissionCandidateError> {
    if caller_cpu != 0 {
        return Err(G8lS410ExclusionAdmissionCandidateError::WrongCpu);
    }
    if let Some(existing) = candidates.pending_view(caller_cpu)? {
        return Ok(G8lS410ExclusionAdmissionCandidateOutcome::CandidatePending(
            existing,
        ));
    }
    let Some(view) = delivery.pending_receipt_view() else {
        return Ok(G8lS410ExclusionAdmissionCandidateOutcome::Idle);
    };
    if !receipt_matches_live_gate(view, active_exclusive_token) {
        return Err(G8lS410ExclusionAdmissionCandidateError::GateTokenMismatch);
    }
    let receipt = delivery
        .take_receipt(caller_cpu)
        .map_err(G8lS410ExclusionAdmissionCandidateError::S409)?
        .ok_or(G8lS410ExclusionAdmissionCandidateError::ReceiptDisappeared)?;
    if receipt.view() != view {
        return Err(G8lS410ExclusionAdmissionCandidateError::ReceiptDrift);
    }
    let candidate = G8lS410ExclusionAdmissionCandidate::new(receipt);
    let published = candidates.publish(caller_cpu, candidate)?;
    Ok(G8lS410ExclusionAdmissionCandidateOutcome::CandidatePublished(published))
}

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

#[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
pub fn service_s410_exclusion_admission_candidate_publication_on_cpu0(
) -> Result<G8lS410ExclusionAdmissionCandidateOutcome, G8lS410ExclusionAdmissionCandidateError> {
    use crate::g8l_runtime_contract::CPU0;
    if crate::percpu::try_current_cpu_id() != Some(CPU0) {
        return Err(G8lS410ExclusionAdmissionCandidateError::WrongCpu);
    }
    if let Some(existing) = S410_PRODUCTION_CANDIDATES.lock().pending_view(CPU0)? {
        return Ok(G8lS410ExclusionAdmissionCandidateOutcome::CandidatePending(
            existing,
        ));
    }
    let Some(view) = crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s409_live_offer_sgi_delivery::inspect_s409_live_offer_sgi_delivery_receipt_on_cpu0()
        .map_err(G8lS410ExclusionAdmissionCandidateError::S409)? else {
        return Ok(G8lS410ExclusionAdmissionCandidateOutcome::Idle);
    };
    let active_token = crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s246_whole_scheduler_read_access_guard::S247_PRODUCTION_WHOLE_SCHEDULER_ACCESS_GATE
        .active_exclusive_token();
    if !receipt_matches_live_gate(view, active_token) {
        return Err(G8lS410ExclusionAdmissionCandidateError::GateTokenMismatch);
    }
    let receipt = crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s409_live_offer_sgi_delivery::take_s409_live_offer_sgi_delivery_receipt_on_cpu0()
        .map_err(G8lS410ExclusionAdmissionCandidateError::S409)?
        .ok_or(G8lS410ExclusionAdmissionCandidateError::ReceiptDisappeared)?;
    if receipt.view() != view {
        return Err(G8lS410ExclusionAdmissionCandidateError::ReceiptDrift);
    }
    let candidate = G8lS410ExclusionAdmissionCandidate::new(receipt);
    let published = S410_PRODUCTION_CANDIDATES.lock().publish(CPU0, candidate)?;
    Ok(G8lS410ExclusionAdmissionCandidateOutcome::CandidatePublished(published))
}

#[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
pub fn inspect_s410_exclusion_admission_candidate_on_cpu0(
) -> Result<Option<G8lS410ExclusionAdmissionCandidateView>, G8lS410ExclusionAdmissionCandidateError>
{
    use crate::g8l_runtime_contract::CPU0;
    S410_PRODUCTION_CANDIDATES.lock().pending_view(CPU0)
}

#[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
pub fn take_s410_exclusion_admission_candidate_on_cpu0(
) -> Result<Option<G8lS410ExclusionAdmissionCandidate>, G8lS410ExclusionAdmissionCandidateError> {
    use crate::g8l_runtime_contract::CPU0;
    S410_PRODUCTION_CANDIDATES.lock().take(CPU0)
}

#![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, 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_s404_scoped_authority_request_publication::{
    service_s404_model_scoped_authority_request_publication,
    G8lS404ScopedAuthorityRequestState,
};
use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s407_live_exclusion_offer_publication::{
    try_publish_s407_model_live_exclusion_offer, G8lS407LiveExclusionOfferState,
};
use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s408_live_offer_sgi_sender::{
    service_s408_model_live_offer_sgi_send, G8lS408LiveOfferSgiSenderState,
    S408_EXPECTED_ENABLE, S408_EXPECTED_RAW_ACK,
};
use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s409_live_offer_sgi_delivery::{
    service_s409_model_live_offer_sgi_delivery, G8lS409LiveOfferSgiDeliveryState,
    S409_DIRECT_SCHEDULER_ACCESS_SITES, S409_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES,
    S409_SOURCE_AUDIT_UNITS, S409_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES,
    S409_UNROUTED_DIRECT_ACCESS_SITES,
};
use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s410_exclusion_admission_candidate_publication::*;

fn delivered() -> (
    G8lS247WholeSchedulerAccessGate,
    G8lS409LiveOfferSgiDeliveryState,
) {
    let gate = G8lS247WholeSchedulerAccessGate::new();
    let mut providers = G8lS245WholeSchedulerExclusionAdmissionRequestState::new();
    service_s245_exclusion_admission_request(&mut providers, S245_SOURCE_CPU0, true, true).unwrap();
    let mut observations = G8lS402ProviderInvocationObservationState::new();
    service_s402_model_provider_invocation_observation_publication(
        &mut observations,
        &gate,
        &mut providers,
        S245_TARGET_CPU1,
    )
    .unwrap();
    let mut scoped = G8lS404ScopedAuthorityRequestState::new();
    service_s404_model_scoped_authority_request_publication(
        &mut scoped,
        &mut observations,
        S245_SOURCE_CPU0,
    )
    .unwrap();
    service_s245_exclusion_admission_request(&mut providers, S245_SOURCE_CPU0, true, true).unwrap();
    let mut offers = G8lS407LiveExclusionOfferState::new();
    let offered = try_publish_s407_model_live_exclusion_offer(
        &mut offers,
        &gate,
        &mut providers,
        &mut scoped,
        S245_TARGET_CPU1,
    )
    .unwrap()
    .unwrap();
    let offer = offered.offer();
    let mut sender = G8lS408LiveOfferSgiSenderState::new();
    sender
        .prepare_receiver(0, 1, S408_EXPECTED_ENABLE, 1, 0)
        .unwrap();
    let send = service_s408_model_live_offer_sgi_send(&mut sender, 1, &offered).unwrap();
    let mut delivery = G8lS409LiveOfferSgiDeliveryState::new();
    service_s409_model_live_offer_sgi_delivery(
        &mut delivery,
        0,
        S408_EXPECTED_RAW_ACK,
        send,
        offer,
        gate.active_exclusive_token(),
        |_| Ok::<(), ()>(()),
    )
    .unwrap();
    core::mem::forget(offered);
    (gate, delivery)
}

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

fn s409_source() -> &'static str {
    include_str!("../../kernel/src/g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s409_live_offer_sgi_delivery.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_revalidated_admission_candidate_slot() {
    assert_eq!(S410_SOURCE_AUDIT_UNITS, 7);
    assert_eq!(S410_DIRECT_SCHEDULER_ACCESS_SITES, 113);
    assert_eq!(S410_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES, 113);
    assert_eq!(S410_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES, 113);
    assert_eq!(S410_UNROUTED_DIRECT_ACCESS_SITES, 0);
    assert_eq!(S410_ADMISSION_CANDIDATE_SLOT_CAPACITY, 1);
    assert_eq!(S410_PRODUCTION_CANDIDATE_PUBLISHER_CALLSITES, 1);
    assert_eq!(S410_PRODUCTION_S244_ADMISSION_PUBLISHER_SITES, 0);
    assert!(S410_LIVE_GATE_REVALIDATION_REQUIRED_AT_CONSUMPTION);
    assert!(S410_EXCLUSION_ADMISSION_CANDIDATE_PUBLICATION_COMPLETE);
    assert!(!S410_END_TO_END_EXCLUSION_ADMISSION_COMPLETE);
}

#[test]
fn s409_is_the_exact_post_eoi_predecessor() {
    assert_eq!(S410_SOURCE_AUDIT_UNITS, S409_SOURCE_AUDIT_UNITS);
    assert_eq!(
        S410_DIRECT_SCHEDULER_ACCESS_SITES,
        S409_DIRECT_SCHEDULER_ACCESS_SITES
    );
    assert_eq!(
        S410_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES,
        S409_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES
    );
    assert_eq!(
        S410_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES,
        S409_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES
    );
    assert_eq!(
        S410_UNROUTED_DIRECT_ACCESS_SITES,
        S409_UNROUTED_DIRECT_ACCESS_SITES
    );
}

#[test]
fn exact_post_eoi_receipt_and_live_gate_publish_linear_candidate() {
    let (gate, mut delivery) = delivered();
    let mut candidates = G8lS410ExclusionAdmissionCandidateState::new();
    let outcome = service_s410_model_exclusion_admission_candidate_publication(
        &mut candidates,
        &mut delivery,
        S245_SOURCE_CPU0,
        gate.active_exclusive_token(),
    )
    .unwrap();
    let G8lS410ExclusionAdmissionCandidateOutcome::CandidatePublished(view) = outcome else {
        panic!("exact live receipt must publish candidate")
    };
    assert_eq!(view.attempt_id, 1);
    assert_eq!(view.provider_request_id, 2);
    assert_eq!(view.exclusive_token, 2);
    assert!(view.requires_live_gate_revalidation);
    assert!(!view.is_authority);
    assert!(!view.whole_scheduler_exclusion_proven);
    assert!(candidates.pending());
    assert!(!delivery.receipt_pending());
}

#[test]
fn absent_delivery_receipt_is_idle() {
    let mut delivery = G8lS409LiveOfferSgiDeliveryState::new();
    let mut candidates = G8lS410ExclusionAdmissionCandidateState::new();
    assert_eq!(
        service_s410_model_exclusion_admission_candidate_publication(
            &mut candidates,
            &mut delivery,
            0,
            Some(2)
        ),
        Ok(G8lS410ExclusionAdmissionCandidateOutcome::Idle)
    );
}

#[test]
fn stale_gate_token_fails_before_consuming_receipt() {
    let (_gate, mut delivery) = delivered();
    let mut candidates = G8lS410ExclusionAdmissionCandidateState::new();
    assert_eq!(
        service_s410_model_exclusion_admission_candidate_publication(
            &mut candidates,
            &mut delivery,
            0,
            Some(9)
        ),
        Err(G8lS410ExclusionAdmissionCandidateError::GateTokenMismatch)
    );
    assert!(delivery.receipt_pending());
    assert!(!candidates.pending());
}

#[test]
fn occupied_candidate_slot_backpressures_before_consuming_next_receipt() {
    let (gate, mut first_delivery) = delivered();
    let mut candidates = G8lS410ExclusionAdmissionCandidateState::new();
    service_s410_model_exclusion_admission_candidate_publication(
        &mut candidates,
        &mut first_delivery,
        0,
        gate.active_exclusive_token(),
    )
    .unwrap();
    let first = candidates.pending_view(0).unwrap().unwrap();
    let (_next_gate, mut next_delivery) = delivered();
    assert_eq!(
        service_s410_model_exclusion_admission_candidate_publication(
            &mut candidates,
            &mut next_delivery,
            0,
            Some(first.exclusive_token)
        ),
        Ok(G8lS410ExclusionAdmissionCandidateOutcome::CandidatePending(
            first
        ))
    );
    assert!(next_delivery.receipt_pending());
}

#[test]
fn wrong_cpu_preserves_delivery_receipt() {
    let (gate, mut delivery) = delivered();
    let mut candidates = G8lS410ExclusionAdmissionCandidateState::new();
    assert_eq!(
        service_s410_model_exclusion_admission_candidate_publication(
            &mut candidates,
            &mut delivery,
            1,
            gate.active_exclusive_token()
        ),
        Err(G8lS410ExclusionAdmissionCandidateError::WrongCpu)
    );
    assert!(delivery.receipt_pending());
}

#[test]
fn candidate_is_linear_and_view_cannot_claim_authority() {
    assert!(core::mem::needs_drop::<G8lS410ExclusionAdmissionCandidate>());
    let source = module_source();
    let start = source
        .find("pub struct G8lS410ExclusionAdmissionCandidate")
        .unwrap();
    let derive = source[..start].rfind("#[derive").unwrap();
    assert_eq!(
        source[derive..start].trim(),
        "#[derive(Debug, PartialEq, Eq)]"
    );
    assert!(source.contains("whole_scheduler_exclusion_proven: false"));
}

#[test]
fn cpu0_take_is_one_shot_but_does_not_skip_live_revalidation_contract() {
    let (gate, mut delivery) = delivered();
    let mut candidates = G8lS410ExclusionAdmissionCandidateState::new();
    service_s410_model_exclusion_admission_candidate_publication(
        &mut candidates,
        &mut delivery,
        0,
        gate.active_exclusive_token(),
    )
    .unwrap();
    let candidate = candidates.take(0).unwrap().unwrap();
    assert!(candidate.requires_live_gate_revalidation());
    assert!(!candidate.whole_scheduler_exclusion_proven());
    assert!(candidates.take(0).unwrap().is_none());
}

#[test]
fn model_orders_backpressure_inspection_revalidation_take_then_publish() {
    let source = module_source();
    let start = source
        .find("pub fn service_s410_model_exclusion_admission_candidate_publication")
        .unwrap();
    let function: String = source[start..].split_whitespace().collect();
    let pending = function
        .find("candidates.pending_view(caller_cpu)")
        .unwrap();
    let inspect = function.find("delivery.pending_receipt_view()").unwrap();
    let validate = function
        .find("receipt_matches_live_gate(view,active_exclusive_token)")
        .unwrap();
    let take = function.find("delivery.take_receipt(caller_cpu)").unwrap();
    let publish = function.find("candidates.publish(").unwrap();
    assert!(pending < inspect && inspect < validate && validate < take && take < publish);
}

#[test]
fn s409_irq_path_invokes_s410_only_after_delivery_service() {
    let source = s409_source();
    let delivery = source
        .find("service_s409_model_live_offer_sgi_delivery(")
        .unwrap();
    let candidate = source
        .find("service_s410_exclusion_admission_candidate_publication_on_cpu0")
        .unwrap();
    assert!(delivery < candidate);
}

#[test]
fn production_service_revalidates_shared_gate_before_taking_s409_receipt() {
    let source = module_source();
    let start = source
        .find("service_s410_exclusion_admission_candidate_publication_on_cpu0")
        .unwrap();
    let function = &source[start..];
    let inspect = function
        .find("inspect_s409_live_offer_sgi_delivery_receipt_on_cpu0")
        .unwrap();
    let gate = function
        .find("S247_PRODUCTION_WHOLE_SCHEDULER_ACCESS_GATE")
        .unwrap();
    let take = function
        .find("take_s409_live_offer_sgi_delivery_receipt_on_cpu0")
        .unwrap();
    assert!(inspect < gate && gate < take);
}

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

#[test]
fn s410_is_registered_separately_before_exact_s411_successor() {
    let name = "g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s410_exclusion_admission_candidate_publication";
    assert!(kernel_main_source().contains(&format!("mod {name};")));
    assert!(simulation_lib_source().contains(&format!("pub mod {name};")));
    let next = "g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s411_ephemeral_exclusion_admission_constructor";
    assert!(kernel_main_source().contains(&format!("mod {next};")));
    assert!(simulation_lib_source().contains(&format!("pub mod {next};")));
}

  {
    id: "g8l-s410-exclusion-admission-candidate-publication-partial",
    sequence: 410,
    slug: "exclusion_admission_candidate_publication",
    title: "Exclusion admission candidate publication",
    focusedTests: 14,
    sourceBytes: 10426,
    sourceSha256:
      "cb3b0a751270e78206cc5a6a4401dec85e5b0a58a6584040d657bc54643f741b",
    testBytes: 13293,
    testSha256:
      "90152937e86fc1bcb5ad3229ccb6c0f5832e6582d50088cff27d771f45d19b7e",
    acceptance:
      "CPU0 exact S409 delivery receipt'ini one-shot tüketip live-token metadata'lı capacity-one exclusion-admission candidate yayımlar.",
    retainedBoundary:
      "Candidate S244 admission değildir; canlı gate token tüketim anında yeniden doğrulanmalıdır.",
  },