S402 · Provider invocation observation publication

#![allow(unexpected_cfgs)]

//! S402 bounded post-release provider-invocation observation publication.
//!
//! S401 invokes S400 on CPU1 and releases the exclusive lease before returning
//! a non-authoritative receipt. S402 retains that receipt in one bounded slot
//! instead of dropping it at the timer callsite. An occupied slot backpressures
//! before S401 runs, so a later S245 request is not consumed without room for
//! its corresponding observation.
//!
//! The copyable observation exists only after authority release. It therefore
//! cannot prove live exclusion, satisfy S244, or authorize S243/S236. The
//! production callsite is source-wired; physical runtime observation remains
//! zero until a supported-profile run records it.

use crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s244_whole_scheduler_exclusion_admission_request::{
    G8lS245WholeSchedulerExclusionAdmissionRequestState, S245_SOURCE_CPU0, S245_TARGET_CPU1,
};
use crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s246_whole_scheduler_read_access_guard::G8lS247WholeSchedulerAccessGate;
use crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s401_provider_authority_timer_callsite::{
    service_s401_model_provider_authority_timer_callsite,
    G8lS401ProviderAuthorityTimerCallsiteError, G8lS401ProviderAuthorityTimerCallsiteOutcome,
    G8lS401ProviderAuthorityTimerCallsiteReceipt, S401_DIRECT_SCHEDULER_ACCESS_SITES,
    S401_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES, S401_SOURCE_AUDIT_UNITS,
    S401_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES, S401_UNROUTED_DIRECT_ACCESS_SITES,
};

pub const S402_SOURCE_AUDIT_UNITS: usize = S401_SOURCE_AUDIT_UNITS;
pub const S402_DIRECT_SCHEDULER_ACCESS_SITES: usize = S401_DIRECT_SCHEDULER_ACCESS_SITES;
pub const S402_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES: usize =
    S401_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES;
pub const S402_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES: usize =
    S401_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES;
pub const S402_UNROUTED_DIRECT_ACCESS_SITES: usize = S401_UNROUTED_DIRECT_ACCESS_SITES;
pub const S402_OBSERVATION_SLOT_CAPACITY: usize = 1;
pub const S402_PRODUCTION_OBSERVATION_PUBLISHER_SITES: usize = 1;
pub const S402_PRODUCTION_ADMISSION_PUBLISHER_SITES: usize = 0;
pub const S402_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS: usize = 0;
pub const S402_PROVIDER_INVOCATION_OBSERVATION_PUBLICATION_COMPLETE: bool = true;
pub const S402_END_TO_END_EXCLUSION_ADMISSION_COMPLETE: bool = false;

/// Copyable post-release audit data. The fields identify the completed S401
/// invocation but do not retain its request, preflight receipt, or S247 lease.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS402ProviderInvocationObservation {
    request_id: u64,
    exclusive_token: u64,
}

impl G8lS402ProviderInvocationObservation {
    fn from_s401(receipt: G8lS401ProviderAuthorityTimerCallsiteReceipt) -> Self {
        Self {
            request_id: receipt.request_id(),
            exclusive_token: receipt.exclusive_token(),
        }
    }

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

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

    pub const fn provider_constructor_invoked(&self) -> bool {
        true
    }

    pub const fn authority_released(&self) -> bool {
        true
    }

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

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

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

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

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

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

    pub const fn pending_observation(&self) -> Option<G8lS402ProviderInvocationObservation> {
        self.pending
    }

    fn publish(
        &mut self,
        caller_cpu: usize,
        observation: G8lS402ProviderInvocationObservation,
    ) -> Result<(), G8lS402ProviderInvocationObservationError> {
        if caller_cpu != S245_TARGET_CPU1 {
            return Err(G8lS402ProviderInvocationObservationError::WrongProducerCpu);
        }
        if let Some(existing) = self.pending {
            return Err(G8lS402ProviderInvocationObservationError::SlotOccupied(
                existing,
            ));
        }
        self.pending = Some(observation);
        Ok(())
    }

    pub fn take(
        &mut self,
        caller_cpu: usize,
    ) -> Result<
        Option<G8lS402ProviderInvocationObservation>,
        G8lS402ProviderInvocationObservationError,
    > {
        if caller_cpu != S245_SOURCE_CPU0 {
            return Err(G8lS402ProviderInvocationObservationError::WrongConsumerCpu);
        }
        Ok(self.pending.take())
    }
}

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

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS402ProviderInvocationObservationError {
    WrongProducerCpu,
    WrongConsumerCpu,
    SlotOccupied(G8lS402ProviderInvocationObservation),
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS402ProviderInvocationObservationOutcome {
    Idle,
    ObservationPublished(G8lS402ProviderInvocationObservation),
    ObservationPending(G8lS402ProviderInvocationObservation),
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS402ProviderInvocationObservationServiceError {
    WrongProducerCpu,
    S401(G8lS401ProviderAuthorityTimerCallsiteError),
    State(G8lS402ProviderInvocationObservationError),
}

pub fn service_s402_model_provider_invocation_observation_publication(
    observations: &mut G8lS402ProviderInvocationObservationState,
    gate: &G8lS247WholeSchedulerAccessGate,
    requests: &mut G8lS245WholeSchedulerExclusionAdmissionRequestState,
    caller_cpu: usize,
) -> Result<
    G8lS402ProviderInvocationObservationOutcome,
    G8lS402ProviderInvocationObservationServiceError,
> {
    if caller_cpu != S245_TARGET_CPU1 {
        return Err(G8lS402ProviderInvocationObservationServiceError::WrongProducerCpu);
    }
    if let Some(existing) = observations.pending_observation() {
        return Ok(G8lS402ProviderInvocationObservationOutcome::ObservationPending(existing));
    }
    let outcome = service_s401_model_provider_authority_timer_callsite(gate, requests, caller_cpu)
        .map_err(G8lS402ProviderInvocationObservationServiceError::S401)?;
    let receipt = match outcome {
        G8lS401ProviderAuthorityTimerCallsiteOutcome::Idle => {
            return Ok(G8lS402ProviderInvocationObservationOutcome::Idle)
        }
        G8lS401ProviderAuthorityTimerCallsiteOutcome::ProviderAuthorityInvokedAndReleased(
            receipt,
        ) => receipt,
    };
    let observation = G8lS402ProviderInvocationObservation::from_s401(receipt);
    observations
        .publish(caller_cpu, observation)
        .map_err(G8lS402ProviderInvocationObservationServiceError::State)?;
    Ok(G8lS402ProviderInvocationObservationOutcome::ObservationPublished(observation))
}

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

#[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
pub fn service_s402_provider_invocation_observation_publication_on_cpu1() -> Result<
    G8lS402ProviderInvocationObservationOutcome,
    G8lS402ProviderInvocationObservationServiceError,
> {
    use crate::g8l_runtime_contract::CPU1;

    if crate::percpu::try_current_cpu_id() != Some(CPU1) {
        return Err(G8lS402ProviderInvocationObservationServiceError::WrongProducerCpu);
    }
    if let Some(existing) = S402_PRODUCTION_OBSERVATIONS.lock().pending_observation() {
        return Ok(G8lS402ProviderInvocationObservationOutcome::ObservationPending(existing));
    }
    let outcome = crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s401_provider_authority_timer_callsite::service_s401_provider_authority_timer_callsite_on_cpu1()
        .map_err(G8lS402ProviderInvocationObservationServiceError::S401)?;
    let receipt = match outcome {
        G8lS401ProviderAuthorityTimerCallsiteOutcome::Idle => {
            return Ok(G8lS402ProviderInvocationObservationOutcome::Idle)
        }
        G8lS401ProviderAuthorityTimerCallsiteOutcome::ProviderAuthorityInvokedAndReleased(
            receipt,
        ) => receipt,
    };
    let observation = G8lS402ProviderInvocationObservation::from_s401(receipt);
    S402_PRODUCTION_OBSERVATIONS
        .lock()
        .publish(CPU1, observation)
        .map_err(G8lS402ProviderInvocationObservationServiceError::State)?;
    Ok(G8lS402ProviderInvocationObservationOutcome::ObservationPublished(observation))
}

/// Future CPU0 consumer may inspect the exact post-release observation without
/// taking it. Inspection cannot satisfy S244.
#[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
pub fn inspect_s402_provider_invocation_observation_on_cpu0(
) -> Result<Option<G8lS402ProviderInvocationObservation>, G8lS402ProviderInvocationObservationError>
{
    use crate::g8l_runtime_contract::CPU0;
    if crate::percpu::try_current_cpu_id() != Some(CPU0) {
        return Err(G8lS402ProviderInvocationObservationError::WrongConsumerCpu);
    }
    Ok(S402_PRODUCTION_OBSERVATIONS.lock().pending_observation())
}

/// One-shot extractor exposed for a later boundary; S402 does not invoke it.
#[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
pub fn take_s402_provider_invocation_observation_on_cpu0(
) -> Result<Option<G8lS402ProviderInvocationObservation>, G8lS402ProviderInvocationObservationError>
{
    use crate::g8l_runtime_contract::CPU0;
    if crate::percpu::try_current_cpu_id() != Some(CPU0) {
        return Err(G8lS402ProviderInvocationObservationError::WrongConsumerCpu);
    }
    S402_PRODUCTION_OBSERVATIONS.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, 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_s401_provider_authority_timer_callsite::{
    S401_DIRECT_SCHEDULER_ACCESS_SITES, S401_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES,
    S401_SOURCE_AUDIT_UNITS, S401_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES,
    S401_UNROUTED_DIRECT_ACCESS_SITES,
};
use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s402_provider_invocation_observation_publication::*;

fn pending(next_request_id: u64) -> G8lS245WholeSchedulerExclusionAdmissionRequestState {
    let mut state =
        G8lS245WholeSchedulerExclusionAdmissionRequestState::with_next_request_id(next_request_id);
    assert_eq!(
        service_s245_exclusion_admission_request(&mut state, S245_SOURCE_CPU0, true, true),
        Ok(G8lS245ExclusionAdmissionRequestOutcome::RequestPublished(
            next_request_id
        ))
    );
    state
}

fn module_source() -> &'static str {
    include_str!("../../kernel/src/g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s402_provider_invocation_observation_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_bounded_post_release_observation_slot() {
    assert_eq!(S402_SOURCE_AUDIT_UNITS, 7);
    assert_eq!(S402_DIRECT_SCHEDULER_ACCESS_SITES, 113);
    assert_eq!(S402_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES, 113);
    assert_eq!(S402_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES, 113);
    assert_eq!(S402_UNROUTED_DIRECT_ACCESS_SITES, 0);
    assert_eq!(S402_OBSERVATION_SLOT_CAPACITY, 1);
    assert_eq!(S402_PRODUCTION_OBSERVATION_PUBLISHER_SITES, 1);
    assert_eq!(S402_PRODUCTION_ADMISSION_PUBLISHER_SITES, 0);
    assert_eq!(S402_SUPPORTED_PROFILE_RUNTIME_OBSERVATIONS, 0);
    assert!(S402_PROVIDER_INVOCATION_OBSERVATION_PUBLICATION_COMPLETE);
    assert!(!S402_END_TO_END_EXCLUSION_ADMISSION_COMPLETE);
}

#[test]
fn s401_is_the_exact_invocation_predecessor() {
    assert_eq!(S402_SOURCE_AUDIT_UNITS, S401_SOURCE_AUDIT_UNITS);
    assert_eq!(
        S402_DIRECT_SCHEDULER_ACCESS_SITES,
        S401_DIRECT_SCHEDULER_ACCESS_SITES
    );
    assert_eq!(
        S402_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES,
        S401_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES
    );
    assert_eq!(
        S402_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES,
        S401_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES
    );
    assert_eq!(
        S402_UNROUTED_DIRECT_ACCESS_SITES,
        S401_UNROUTED_DIRECT_ACCESS_SITES
    );
}

#[test]
fn exact_s401_completion_publishes_one_non_authoritative_observation() {
    let gate = G8lS247WholeSchedulerAccessGate::new();
    let mut requests = pending(73);
    let mut observations = G8lS402ProviderInvocationObservationState::new();
    let outcome = service_s402_model_provider_invocation_observation_publication(
        &mut observations,
        &gate,
        &mut requests,
        S245_TARGET_CPU1,
    )
    .unwrap();
    let G8lS402ProviderInvocationObservationOutcome::ObservationPublished(observation) = outcome
    else {
        panic!("exact invocation must publish one observation")
    };
    assert_eq!(observation.request_id(), 73);
    assert_eq!(observation.exclusive_token(), 1);
    assert!(observation.provider_constructor_invoked());
    assert!(observation.authority_released());
    assert!(!observation.authority_live());
    assert!(!observation.whole_scheduler_exclusion_proven());
    assert!(!observation.admission_published());
    assert_eq!(observations.pending_observation(), Some(observation));
    assert_eq!(gate.active_exclusive_token(), None);
}

#[test]
fn no_request_is_idle_and_leaves_the_observation_slot_empty() {
    let gate = G8lS247WholeSchedulerAccessGate::new();
    let mut requests = G8lS245WholeSchedulerExclusionAdmissionRequestState::new();
    let mut observations = G8lS402ProviderInvocationObservationState::new();
    assert_eq!(
        service_s402_model_provider_invocation_observation_publication(
            &mut observations,
            &gate,
            &mut requests,
            S245_TARGET_CPU1,
        ),
        Ok(G8lS402ProviderInvocationObservationOutcome::Idle)
    );
    assert!(!observations.pending());
}

#[test]
fn occupied_slot_backpressures_before_s401_can_consume_the_next_request() {
    let gate = G8lS247WholeSchedulerAccessGate::new();
    let mut requests = pending(1);
    let mut observations = G8lS402ProviderInvocationObservationState::new();
    let first = service_s402_model_provider_invocation_observation_publication(
        &mut observations,
        &gate,
        &mut requests,
        S245_TARGET_CPU1,
    )
    .unwrap();
    let G8lS402ProviderInvocationObservationOutcome::ObservationPublished(first) = first else {
        panic!("first observation must publish")
    };
    assert_eq!(
        service_s245_exclusion_admission_request(&mut requests, S245_SOURCE_CPU0, true, true),
        Ok(G8lS245ExclusionAdmissionRequestOutcome::RequestPublished(2))
    );
    assert_eq!(
        service_s402_model_provider_invocation_observation_publication(
            &mut observations,
            &gate,
            &mut requests,
            S245_TARGET_CPU1,
        ),
        Ok(G8lS402ProviderInvocationObservationOutcome::ObservationPending(first))
    );
    assert_eq!(requests.pending_request_id(), Some(2));
    assert_eq!(gate.active_exclusive_token(), None);
}

#[test]
fn only_cpu0_can_take_the_observation_and_it_is_one_shot() {
    let gate = G8lS247WholeSchedulerAccessGate::new();
    let mut requests = pending(5);
    let mut observations = G8lS402ProviderInvocationObservationState::new();
    service_s402_model_provider_invocation_observation_publication(
        &mut observations,
        &gate,
        &mut requests,
        S245_TARGET_CPU1,
    )
    .unwrap();
    assert_eq!(
        observations.take(S245_TARGET_CPU1),
        Err(G8lS402ProviderInvocationObservationError::WrongConsumerCpu)
    );
    let observation = observations.take(S245_SOURCE_CPU0).unwrap().unwrap();
    assert_eq!(observation.request_id(), 5);
    assert!(!observations.pending());
    assert_eq!(observations.take(S245_SOURCE_CPU0), Ok(None));
}

#[test]
fn wrong_producer_cpu_preserves_both_request_and_empty_slot() {
    let gate = G8lS247WholeSchedulerAccessGate::new();
    let mut requests = pending(11);
    let mut observations = G8lS402ProviderInvocationObservationState::new();
    assert!(matches!(
        service_s402_model_provider_invocation_observation_publication(
            &mut observations,
            &gate,
            &mut requests,
            S245_SOURCE_CPU0,
        ),
        Err(G8lS402ProviderInvocationObservationServiceError::WrongProducerCpu)
    ));
    assert_eq!(requests.pending_request_id(), Some(11));
    assert!(!observations.pending());
}

#[test]
fn model_service_checks_backpressure_before_invoking_s401_then_publishes() {
    let source = module_source();
    let start = source
        .find("pub fn service_s402_model_provider_invocation_observation_publication")
        .unwrap();
    let function: String = source[start..].split_whitespace().collect();
    let pending = function.find("observations.pending_observation()").unwrap();
    let invoke = function
        .find("service_s401_model_provider_authority_timer_callsite")
        .unwrap();
    let publish = function.find("observations.publish(").unwrap();
    assert!(pending < invoke && invoke < publish);
}

#[test]
fn observation_type_is_copyable_but_explicitly_non_authoritative() {
    assert!(!core::mem::needs_drop::<G8lS402ProviderInvocationObservation>());
    let source = module_source();
    let start = source
        .find("pub struct G8lS402ProviderInvocationObservation")
        .unwrap();
    let derive = source[..start].rfind("#[derive").unwrap();
    assert!(source[derive..start].contains("Clone, Copy"));
    let section = &source[start..source[start..].find("#[derive").unwrap() + start];
    assert!(section.contains("pub const fn authority_live(&self) -> bool"));
    assert!(section.contains("pub const fn whole_scheduler_exclusion_proven(&self) -> bool"));
}

#[test]
fn production_service_is_the_only_direct_s401_runtime_invoker() {
    let source = module_source();
    assert_eq!(
        source
            .matches("service_s401_provider_authority_timer_callsite_on_cpu1")
            .count(),
        1
    );
    assert!(!exception_source().contains("service_s401_provider_authority_timer_callsite_on_cpu1"));
}

#[test]
fn timer_chain_invokes_s402_after_s399_and_before_s242() {
    let source = exception_source();
    let s399 = source
        .find("service_s399_whole_scheduler_provider_preflight_on_cpu1")
        .unwrap();
    let s402 = source
        .find("service_s402_provider_invocation_observation_publication_on_cpu1")
        .unwrap();
    let s242 = source
        .find("service_s242_sender_runtime_callsite_request_on_cpu1")
        .unwrap();
    assert!(s399 < s402 && s402 < s242);
    assert_eq!(
        source
            .matches("service_s402_provider_invocation_observation_publication_on_cpu1")
            .count(),
        1
    );
}

#[test]
fn timer_chain_accepts_idle_published_or_pending_and_panics_on_error() {
    let source = exception_source();
    for marker in [
        "G8lS402ProviderInvocationObservationOutcome::Idle",
        "G8lS402ProviderInvocationObservationOutcome::ObservationPublished",
        "G8lS402ProviderInvocationObservationOutcome::ObservationPending",
        "S402 provider-invocation observation publication failed closed",
    ] {
        assert!(source.contains(marker), "missing timer marker {marker}");
    }
}

#[test]
fn production_slot_and_service_use_exact_supported_profile_cfg() {
    let source = module_source();
    assert!(source.contains("target_arch = \"aarch64\""));
    assert!(source.contains("target_os = \"none\""));
    assert!(source.contains("feature = \"board-rpi5\""));
    assert!(source.contains("static S402_PRODUCTION_OBSERVATIONS"));
    assert!(source.contains("crate::percpu::try_current_cpu_id()"));
}

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

#[test]
fn s402_and_its_exact_s403_consumer_are_registered_separately() {
    let s402 = "g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s402_provider_invocation_observation_publication";
    let s403 = "g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s403_provider_invocation_observation_consumer";
    assert!(kernel_main_source().contains(&format!("mod {s402};")));
    assert!(simulation_lib_source().contains(&format!("pub mod {s402};")));
    assert!(kernel_main_source().contains(&format!("mod {s403};")));
    assert!(simulation_lib_source().contains(&format!("pub mod {s403};")));
}

  {
    id: "g8l-s402-provider-invocation-observation-publication-partial",
    sequence: 402,
    slug: "provider_invocation_observation_publication",
    title: "Provider invocation observation publication",
    focusedTests: 15,
    sourceBytes: 10416,
    sourceSha256:
      "5e94c9cd1a03a65235bf17374bba28d1a8bcad859e5e2738ac3a35d391cd5ae9",
    testBytes: 12155,
    testSha256:
      "12b7f67037251f279fe4b64aa4d8b39126639ce77fb76e75db07f39b2a29c011",
    acceptance:
      "S401 invocation receipt'i CPU1 üreticili, CPU0 tüketicili capacity-one observation slot'una exact metadata ve monotonic kimlikle yayımlanır.",
    retainedBoundary:
      "Observation admission değildir; CPU0 consumer ve scoped request zinciri S403/S404'e ayrılmıştır.",
  },