S411 · Ephemeral exclusion admission constructor

#![allow(unexpected_cfgs)]

//! S411 ephemeral whole-scheduler-exclusion admission constructor.
//!
//! S410's linear candidate still denies authority. S411 inspects that
//! candidate, matches its exact nonzero token against the currently active
//! S247 exclusive lease a third time, and only then consumes it into one
//! non-Copy CPU0 admission. The admission remains valid only while that exact
//! token is live; it is not a standalone authority and S411 does not enter the
//! S243 join or the sealed historical S244 placeholder.

use crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s410_exclusion_admission_candidate_publication::{
    G8lS410ExclusionAdmissionCandidate, G8lS410ExclusionAdmissionCandidateError,
    G8lS410ExclusionAdmissionCandidateState, G8lS410ExclusionAdmissionCandidateView,
    S410_DIRECT_SCHEDULER_ACCESS_SITES, S410_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES,
    S410_SOURCE_AUDIT_UNITS, S410_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES,
    S410_UNROUTED_DIRECT_ACCESS_SITES,
};

pub const S411_SOURCE_AUDIT_UNITS: usize = S410_SOURCE_AUDIT_UNITS;
pub const S411_DIRECT_SCHEDULER_ACCESS_SITES: usize = S410_DIRECT_SCHEDULER_ACCESS_SITES;
pub const S411_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES: usize =
    S410_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES;
pub const S411_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES: usize =
    S410_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES;
pub const S411_UNROUTED_DIRECT_ACCESS_SITES: usize = S410_UNROUTED_DIRECT_ACCESS_SITES;
pub const S411_EPHEMERAL_ADMISSION_SLOT_CAPACITY: usize = 1;
pub const S411_PRODUCTION_CONSTRUCTOR_CALLSITES: usize = 1;
pub const S411_PRODUCTION_S243_JOIN_CALLSITES: usize = 0;
pub const S411_THIRD_LIVE_GATE_TOKEN_REVALIDATION_COMPLETE: bool = true;
pub const S411_END_TO_END_EXCLUSION_ADMISSION_COMPLETE: bool = false;

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

impl G8lS411EphemeralExclusionAdmission {
    fn new(candidate: G8lS410ExclusionAdmissionCandidate) -> Self {
        Self { candidate }
    }

    pub const fn attempt_id(&self) -> u64 {
        self.candidate.attempt_id()
    }
    pub const fn provider_request_id(&self) -> u64 {
        self.candidate.provider_request_id()
    }
    pub const fn exclusive_token(&self) -> u64 {
        self.candidate.exclusive_token()
    }
    pub const fn is_standalone_authority(&self) -> bool {
        false
    }
    pub const fn live_gate_matched_at_construction(&self) -> bool {
        true
    }
    pub const fn requires_live_gate_match_at_consumption(&self) -> bool {
        true
    }
    pub const fn view(&self) -> G8lS411EphemeralExclusionAdmissionView {
        G8lS411EphemeralExclusionAdmissionView {
            attempt_id: self.attempt_id(),
            provider_request_id: self.provider_request_id(),
            exclusive_token: self.exclusive_token(),
            live_gate_matched_at_construction: true,
            requires_live_gate_match_at_consumption: true,
            is_standalone_authority: false,
        }
    }

    pub fn validate_live_token(&self, active_exclusive_token: Option<u64>) -> bool {
        self.exclusive_token() != 0 && active_exclusive_token == Some(self.exclusive_token())
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS411EphemeralExclusionAdmissionView {
    pub attempt_id: u64,
    pub provider_request_id: u64,
    pub exclusive_token: u64,
    pub live_gate_matched_at_construction: bool,
    pub requires_live_gate_match_at_consumption: bool,
    pub is_standalone_authority: bool,
}

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

impl G8lS411EphemeralExclusionAdmissionState {
    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<G8lS411EphemeralExclusionAdmissionView>,
        G8lS411EphemeralExclusionAdmissionError,
    > {
        if caller_cpu != 0 {
            return Err(G8lS411EphemeralExclusionAdmissionError::WrongCpu);
        }
        Ok(self
            .pending
            .as_ref()
            .map(G8lS411EphemeralExclusionAdmission::view))
    }

    fn publish(
        &mut self,
        caller_cpu: usize,
        admission: G8lS411EphemeralExclusionAdmission,
    ) -> Result<G8lS411EphemeralExclusionAdmissionView, G8lS411EphemeralExclusionAdmissionError>
    {
        if caller_cpu != 0 {
            return Err(G8lS411EphemeralExclusionAdmissionError::WrongCpu);
        }
        if self.pending.is_some() {
            return Err(G8lS411EphemeralExclusionAdmissionError::SlotOccupied);
        }
        let view = admission.view();
        self.pending = Some(admission);
        Ok(view)
    }

    pub fn take(
        &mut self,
        caller_cpu: usize,
    ) -> Result<Option<G8lS411EphemeralExclusionAdmission>, G8lS411EphemeralExclusionAdmissionError>
    {
        if caller_cpu != 0 {
            return Err(G8lS411EphemeralExclusionAdmissionError::WrongCpu);
        }
        Ok(self.pending.take())
    }

    pub(crate) fn restore(
        &mut self,
        caller_cpu: usize,
        admission: G8lS411EphemeralExclusionAdmission,
    ) -> Result<G8lS411EphemeralExclusionAdmissionView, G8lS411EphemeralExclusionAdmissionError>
    {
        self.publish(caller_cpu, admission)
    }
}

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

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS411EphemeralExclusionAdmissionError {
    WrongCpu,
    S410(G8lS410ExclusionAdmissionCandidateError),
    SlotOccupied,
    GateTokenMismatch,
    CandidateDisappeared,
    CandidateDrift,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS411EphemeralExclusionAdmissionOutcome {
    Idle,
    AdmissionConstructed(G8lS411EphemeralExclusionAdmissionView),
    AdmissionPending(G8lS411EphemeralExclusionAdmissionView),
}

fn candidate_matches_live_gate(
    candidate: G8lS410ExclusionAdmissionCandidateView,
    active_exclusive_token: Option<u64>,
) -> bool {
    candidate.attempt_id != 0
        && candidate.provider_request_id != 0
        && candidate.exclusive_token != 0
        && candidate.requires_live_gate_revalidation
        && !candidate.is_authority
        && !candidate.whole_scheduler_exclusion_proven
        && active_exclusive_token == Some(candidate.exclusive_token)
}

pub fn service_s411_model_ephemeral_exclusion_admission_constructor(
    admissions: &mut G8lS411EphemeralExclusionAdmissionState,
    candidates: &mut G8lS410ExclusionAdmissionCandidateState,
    caller_cpu: usize,
    active_exclusive_token: Option<u64>,
) -> Result<G8lS411EphemeralExclusionAdmissionOutcome, G8lS411EphemeralExclusionAdmissionError> {
    if caller_cpu != 0 {
        return Err(G8lS411EphemeralExclusionAdmissionError::WrongCpu);
    }
    if let Some(existing) = admissions.pending_view(caller_cpu)? {
        return Ok(G8lS411EphemeralExclusionAdmissionOutcome::AdmissionPending(
            existing,
        ));
    }
    let Some(view) = candidates
        .pending_view(caller_cpu)
        .map_err(G8lS411EphemeralExclusionAdmissionError::S410)?
    else {
        return Ok(G8lS411EphemeralExclusionAdmissionOutcome::Idle);
    };
    if !candidate_matches_live_gate(view, active_exclusive_token) {
        return Err(G8lS411EphemeralExclusionAdmissionError::GateTokenMismatch);
    }
    let candidate = candidates
        .take(caller_cpu)
        .map_err(G8lS411EphemeralExclusionAdmissionError::S410)?
        .ok_or(G8lS411EphemeralExclusionAdmissionError::CandidateDisappeared)?;
    if candidate.view() != view {
        return Err(G8lS411EphemeralExclusionAdmissionError::CandidateDrift);
    }
    let admission = G8lS411EphemeralExclusionAdmission::new(candidate);
    let published = admissions.publish(caller_cpu, admission)?;
    Ok(G8lS411EphemeralExclusionAdmissionOutcome::AdmissionConstructed(published))
}

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

#[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
pub fn service_s411_ephemeral_exclusion_admission_constructor_on_cpu0(
) -> Result<G8lS411EphemeralExclusionAdmissionOutcome, G8lS411EphemeralExclusionAdmissionError> {
    use crate::g8l_runtime_contract::CPU0;
    if crate::percpu::try_current_cpu_id() != Some(CPU0) {
        return Err(G8lS411EphemeralExclusionAdmissionError::WrongCpu);
    }
    if let Some(existing) = S411_PRODUCTION_ADMISSIONS.lock().pending_view(CPU0)? {
        return Ok(G8lS411EphemeralExclusionAdmissionOutcome::AdmissionPending(
            existing,
        ));
    }
    let Some(view) = crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s410_exclusion_admission_candidate_publication::inspect_s410_exclusion_admission_candidate_on_cpu0()
        .map_err(G8lS411EphemeralExclusionAdmissionError::S410)? else {
        return Ok(G8lS411EphemeralExclusionAdmissionOutcome::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 !candidate_matches_live_gate(view, active_token) {
        return Err(G8lS411EphemeralExclusionAdmissionError::GateTokenMismatch);
    }
    let candidate = crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s410_exclusion_admission_candidate_publication::take_s410_exclusion_admission_candidate_on_cpu0()
        .map_err(G8lS411EphemeralExclusionAdmissionError::S410)?
        .ok_or(G8lS411EphemeralExclusionAdmissionError::CandidateDisappeared)?;
    if candidate.view() != view {
        return Err(G8lS411EphemeralExclusionAdmissionError::CandidateDrift);
    }
    let admission = G8lS411EphemeralExclusionAdmission::new(candidate);
    let published = S411_PRODUCTION_ADMISSIONS.lock().publish(CPU0, admission)?;
    Ok(G8lS411EphemeralExclusionAdmissionOutcome::AdmissionConstructed(published))
}

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

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

#[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
pub(crate) fn restore_s411_ephemeral_exclusion_admission_on_cpu0(
    admission: G8lS411EphemeralExclusionAdmission,
) -> Result<G8lS411EphemeralExclusionAdmissionView, G8lS411EphemeralExclusionAdmissionError> {
    use crate::g8l_runtime_contract::CPU0;
    S411_PRODUCTION_ADMISSIONS.lock().restore(CPU0, admission)
}

#![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,
};
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,
};
use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s410_exclusion_admission_candidate_publication::{
    service_s410_model_exclusion_admission_candidate_publication,
    G8lS410ExclusionAdmissionCandidateState,
};
use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s411_ephemeral_exclusion_admission_constructor::*;

fn candidate() -> (
    G8lS247WholeSchedulerAccessGate,
    G8lS410ExclusionAdmissionCandidateState,
) {
    let gate = G8lS247WholeSchedulerAccessGate::new();
    let mut providers = G8lS245WholeSchedulerExclusionAdmissionRequestState::new();
    service_s245_exclusion_admission_request(&mut providers, 0, true, true).unwrap();
    let mut observations = G8lS402ProviderInvocationObservationState::new();
    service_s402_model_provider_invocation_observation_publication(
        &mut observations,
        &gate,
        &mut providers,
        1,
    )
    .unwrap();
    let mut scoped = G8lS404ScopedAuthorityRequestState::new();
    service_s404_model_scoped_authority_request_publication(&mut scoped, &mut observations, 0)
        .unwrap();
    service_s245_exclusion_admission_request(&mut providers, 0, true, true).unwrap();
    let mut offers = G8lS407LiveExclusionOfferState::new();
    let offered = try_publish_s407_model_live_exclusion_offer(
        &mut offers,
        &gate,
        &mut providers,
        &mut scoped,
        1,
    )
    .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();
    let mut candidates = G8lS410ExclusionAdmissionCandidateState::new();
    service_s410_model_exclusion_admission_candidate_publication(
        &mut candidates,
        &mut delivery,
        0,
        gate.active_exclusive_token(),
    )
    .unwrap();
    core::mem::forget(offered);
    (gate, candidates)
}

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

#[test]
fn constants_define_one_ephemeral_admission_constructor() {
    assert_eq!(S411_EPHEMERAL_ADMISSION_SLOT_CAPACITY, 1);
    assert_eq!(S411_PRODUCTION_CONSTRUCTOR_CALLSITES, 1);
    assert_eq!(S411_PRODUCTION_S243_JOIN_CALLSITES, 0);
    assert!(S411_THIRD_LIVE_GATE_TOKEN_REVALIDATION_COMPLETE);
    assert!(!S411_END_TO_END_EXCLUSION_ADMISSION_COMPLETE);
}

#[test]
fn exact_candidate_constructs_linear_ephemeral_admission() {
    let (gate, mut candidates) = candidate();
    let mut admissions = G8lS411EphemeralExclusionAdmissionState::new();
    let outcome = service_s411_model_ephemeral_exclusion_admission_constructor(
        &mut admissions,
        &mut candidates,
        0,
        gate.active_exclusive_token(),
    )
    .unwrap();
    let G8lS411EphemeralExclusionAdmissionOutcome::AdmissionConstructed(view) = outcome else {
        panic!("exact live candidate must construct admission")
    };
    assert_eq!(view.attempt_id, 1);
    assert_eq!(view.provider_request_id, 2);
    assert_eq!(view.exclusive_token, 2);
    assert!(view.live_gate_matched_at_construction);
    assert!(!view.is_standalone_authority);
    assert!(admissions.pending());
    assert!(!candidates.pending());
}

#[test]
fn absent_candidate_is_idle() {
    let mut candidates = G8lS410ExclusionAdmissionCandidateState::new();
    let mut admissions = G8lS411EphemeralExclusionAdmissionState::new();
    assert_eq!(
        service_s411_model_ephemeral_exclusion_admission_constructor(
            &mut admissions,
            &mut candidates,
            0,
            Some(2),
        ),
        Ok(G8lS411EphemeralExclusionAdmissionOutcome::Idle)
    );
}

#[test]
fn stale_token_fails_before_candidate_take() {
    let (_gate, mut candidates) = candidate();
    let mut admissions = G8lS411EphemeralExclusionAdmissionState::new();
    assert_eq!(
        service_s411_model_ephemeral_exclusion_admission_constructor(
            &mut admissions,
            &mut candidates,
            0,
            Some(99),
        ),
        Err(G8lS411EphemeralExclusionAdmissionError::GateTokenMismatch)
    );
    assert!(candidates.pending());
    assert!(!admissions.pending());
}

#[test]
fn occupied_admission_backpressures_without_candidate_take() {
    let (gate, mut candidates) = candidate();
    let mut admissions = G8lS411EphemeralExclusionAdmissionState::new();
    service_s411_model_ephemeral_exclusion_admission_constructor(
        &mut admissions,
        &mut candidates,
        0,
        gate.active_exclusive_token(),
    )
    .unwrap();
    let existing = admissions.pending_view(0).unwrap().unwrap();
    let (_next_gate, mut next_candidate) = candidate();
    assert_eq!(
        service_s411_model_ephemeral_exclusion_admission_constructor(
            &mut admissions,
            &mut next_candidate,
            0,
            Some(existing.exclusive_token),
        ),
        Ok(G8lS411EphemeralExclusionAdmissionOutcome::AdmissionPending(
            existing
        ))
    );
    assert!(next_candidate.pending());
}

#[test]
fn wrong_cpu_preserves_candidate() {
    let (gate, mut candidates) = candidate();
    let mut admissions = G8lS411EphemeralExclusionAdmissionState::new();
    assert_eq!(
        service_s411_model_ephemeral_exclusion_admission_constructor(
            &mut admissions,
            &mut candidates,
            1,
            gate.active_exclusive_token(),
        ),
        Err(G8lS411EphemeralExclusionAdmissionError::WrongCpu)
    );
    assert!(candidates.pending());
}

#[test]
fn admission_is_non_copy_and_still_requires_live_validation() {
    assert!(core::mem::needs_drop::<G8lS411EphemeralExclusionAdmission>());
    let (gate, mut candidates) = candidate();
    let mut admissions = G8lS411EphemeralExclusionAdmissionState::new();
    service_s411_model_ephemeral_exclusion_admission_constructor(
        &mut admissions,
        &mut candidates,
        0,
        gate.active_exclusive_token(),
    )
    .unwrap();
    let admission = admissions.take(0).unwrap().unwrap();
    assert!(admission.validate_live_token(gate.active_exclusive_token()));
    assert!(!admission.validate_live_token(Some(999)));
    assert!(!admission.is_standalone_authority());
}

#[test]
fn constructor_orders_backpressure_inspect_validate_take_publish() {
    let source = module_source();
    let start = source
        .find("pub fn service_s411_model_ephemeral_exclusion_admission_constructor")
        .unwrap();
    let body: String = source[start..].split_whitespace().collect();
    let pending = body.find("admissions.pending_view(caller_cpu)").unwrap();
    let inspect = body.find("candidates.pending_view(caller_cpu)").unwrap();
    let validate = body
        .find("candidate_matches_live_gate(view,active_exclusive_token)")
        .unwrap();
    let take = body.find("candidates.take(caller_cpu)").unwrap();
    let publish = body
        .find("admissions.publish(caller_cpu,admission)")
        .unwrap();
    assert!(pending < inspect && inspect < validate && validate < take && take < publish);
}

#[test]
fn production_constructor_uses_shared_gate_and_exact_s410_take() {
    let source = module_source();
    let start = source
        .find("service_s411_ephemeral_exclusion_admission_constructor_on_cpu0")
        .unwrap();
    let body = &source[start..];
    let inspect = body
        .find("inspect_s410_exclusion_admission_candidate_on_cpu0")
        .unwrap();
    let gate = body
        .find("S247_PRODUCTION_WHOLE_SCHEDULER_ACCESS_GATE")
        .unwrap();
    let take = body
        .find("take_s410_exclusion_admission_candidate_on_cpu0")
        .unwrap();
    assert!(inspect < gate && gate < take);
}

#[test]
fn s409_invokes_s411_only_after_s410_candidate_publication() {
    let source = include_str!("../../kernel/src/g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s409_live_offer_sgi_delivery.rs");
    let s410 = source
        .find("service_s410_exclusion_admission_candidate_publication_on_cpu0")
        .unwrap();
    let s411 = source
        .find("service_s411_ephemeral_exclusion_admission_constructor_on_cpu0")
        .unwrap();
    assert!(s410 < s411);
}

#[test]
fn s411_does_not_enter_s243_or_publish_old_s244_placeholder() {
    let source = module_source();
    assert!(!source.contains("service_s243_deferred_authority_receipt_join"));
    assert!(!source.contains("service_s244_whole_scheduler_exclusion_admission_on_cpu0"));
    assert!(!source.contains("addr_of_mut!("));
}

#[test]
fn s411_is_registered_separately() {
    let name = "g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s411_ephemeral_exclusion_admission_constructor";
    assert!(include_str!("../../kernel/src/main.rs").contains(&format!("mod {name};")));
    assert!(include_str!("../src/lib.rs").contains(&format!("pub mod {name};")));
}

  {
    id: "g8l-s411-ephemeral-exclusion-admission-constructor-partial",
    sequence: 411,
    slug: "ephemeral_exclusion_admission_constructor",
    title: "Ephemeral exclusion admission constructor",
    focusedTests: 12,
    sourceBytes: 11615,
    sourceSha256:
      "351e9c6bec70e75f96d062ce5665d2c54da023f8a598c99a1d729e08fd143c98",
    testBytes: 11374,
    testSha256:
      "e3558905cccef70e4443812b00b1d99e3dec6fbce462c1056dec07d31b5d1aa2",
    acceptance:
      "CPU0 S410 candidate'i alırken offered authority'nin live S247 token'ını üçüncü kez exact revalidate eder ve capacity-one ephemeral admission üretir.",
    retainedBoundary:
      "Ephemeral admission'ın S243 join callsite'ı S413'e kadar açılmaz.",
  },