S423 · S187 continuation invocation

#![allow(unexpected_cfgs)]

//! S423 exact production invocation of the delivered S187 continuation.
//!
//! S423 repeats S422's non-consuming preflight, takes the exact S421 envelope,
//! verifies it did not drift, and moves its non-Copy handoff into the existing
//! `publish_runtime_owner_tuple_from_production_s187_handoff` path. Downstream
//! failure is terminal; no handoff is reconstructed or replayed.

use crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s421_reconciled_s187_handoff_delivery::{
    G8lS421ReconciledS187HandoffDeliveryError, G8lS421ReconciledS187HandoffState,
};
use crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s422_s187_continuation_preflight::{
    preflight_s422_s187_continuation, G8lS422S187ContinuationPreflightError,
    G8lS422S187ContinuationPreflightOutcome, G8lS422S187ContinuationPreflightReceipt,
    S422_DIRECT_SCHEDULER_ACCESS_SITES, S422_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES,
    S422_SOURCE_AUDIT_UNITS, S422_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES,
    S422_UNROUTED_DIRECT_ACCESS_SITES,
};

pub const S423_SOURCE_AUDIT_UNITS: usize = S422_SOURCE_AUDIT_UNITS;
pub const S423_DIRECT_SCHEDULER_ACCESS_SITES: usize = S422_DIRECT_SCHEDULER_ACCESS_SITES;
pub const S423_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES: usize =
    S422_SOURCE_MODEL_COVERED_DIRECT_ACCESS_SITES;
pub const S423_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES: usize =
    S422_PRODUCTION_GUARDED_DIRECT_ACCESS_SITES;
pub const S423_UNROUTED_DIRECT_ACCESS_SITES: usize = S422_UNROUTED_DIRECT_ACCESS_SITES;
pub const S423_PRODUCTION_S187_CONTINUATION_CALLSITES: usize = 1;
pub const S423_S187_CONTINUATION_INVOCATION_COMPLETE: bool = true;
pub const S423_S223_TO_S212_SOURCE_CHAIN_REACHED: bool = true;
pub const S423_SUPPORTED_PROFILE_RUNTIME_OBSERVATION_COMPLETE: bool = false;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct G8lS423S187ContinuationReceipt {
    attempt_id: u64,
    provider_request_id: u64,
    exclusive_token: u64,
}

impl G8lS423S187ContinuationReceipt {
    fn from_preflight(preflight: G8lS422S187ContinuationPreflightReceipt) -> Self {
        Self {
            attempt_id: preflight.attempt_id(),
            provider_request_id: preflight.provider_request_id(),
            exclusive_token: preflight.exclusive_token(),
        }
    }
    pub const fn attempt_id(&self) -> u64 {
        self.attempt_id
    }
    pub const fn provider_request_id(&self) -> u64 {
        self.provider_request_id
    }
    pub const fn exclusive_token(&self) -> u64 {
        self.exclusive_token
    }
    pub const fn s223_to_s212_chain_entered(&self) -> bool {
        true
    }
    pub const fn is_authority(&self) -> bool {
        false
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum G8lS423S187ContinuationOutcome {
    Idle,
    Invoked(G8lS423S187ContinuationReceipt),
}

#[derive(Debug, PartialEq, Eq)]
pub enum G8lS423S187ContinuationError<E> {
    S422(G8lS422S187ContinuationPreflightError),
    S421(G8lS421ReconciledS187HandoffDeliveryError),
    HandoffDisappeared,
    HandoffDrift,
    Consumer(E),
}

pub fn service_s423_model_s187_continuation_invocation<H, E, Consume>(
    delivered: &mut G8lS421ReconciledS187HandoffState<H>,
    caller_cpu: usize,
    active_exclusive_token: Option<u64>,
    irqs_masked: bool,
    consume: Consume,
) -> Result<G8lS423S187ContinuationOutcome, G8lS423S187ContinuationError<E>>
where
    Consume: FnOnce(H) -> Result<(), E>,
{
    let view = delivered
        .pending_view(caller_cpu)
        .map_err(G8lS423S187ContinuationError::S421)?;
    let preflight =
        preflight_s422_s187_continuation(view, caller_cpu, active_exclusive_token, irqs_masked)
            .map_err(G8lS423S187ContinuationError::S422)?;
    let preflight = match preflight {
        G8lS422S187ContinuationPreflightOutcome::Idle => {
            return Ok(G8lS423S187ContinuationOutcome::Idle)
        }
        G8lS422S187ContinuationPreflightOutcome::Ready(receipt) => receipt,
    };
    let view = view.expect("S422 Ready requires an S421 view");
    let envelope = delivered
        .take(caller_cpu)
        .map_err(G8lS423S187ContinuationError::S421)?
        .ok_or(G8lS423S187ContinuationError::HandoffDisappeared)?;
    if envelope.view() != view {
        return Err(G8lS423S187ContinuationError::HandoffDrift);
    }
    let handoff = envelope.into_handoff();
    consume(handoff).map_err(G8lS423S187ContinuationError::Consumer)?;
    Ok(G8lS423S187ContinuationOutcome::Invoked(
        G8lS423S187ContinuationReceipt::from_preflight(preflight),
    ))
}

#[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
#[derive(Debug)]
pub enum G8lS423ProductionS187ContinuationError {
    S422(G8lS422S187ContinuationPreflightError),
    S421(G8lS421ReconciledS187HandoffDeliveryError),
    HandoffDisappeared,
    HandoffDrift,
    Consumer(crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s186_mapping_retirement::G8lProductionMigrationLifecycleS186MappingRetirementError),
}

#[cfg(all(target_arch = "aarch64", target_os = "none", feature = "board-rpi5"))]
pub unsafe fn service_s423_s187_continuation_invocation_on_cpu1(
) -> Result<G8lS423S187ContinuationOutcome, G8lS423ProductionS187ContinuationError> {
    let _irq_guard = crate::arch::aarch64::IrqGuard::new();
    let preflight = crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s422_s187_continuation_preflight::service_s422_s187_continuation_preflight_on_cpu1()
        .map_err(G8lS423ProductionS187ContinuationError::S422)?;
    let preflight = match preflight {
        G8lS422S187ContinuationPreflightOutcome::Idle => {
            return Ok(G8lS423S187ContinuationOutcome::Idle)
        }
        G8lS422S187ContinuationPreflightOutcome::Ready(receipt) => receipt,
    };
    let view = crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s421_reconciled_s187_handoff_delivery::inspect_s421_reconciled_s187_handoff_on_cpu1()
        .map_err(G8lS423ProductionS187ContinuationError::S421)?
        .ok_or(G8lS423ProductionS187ContinuationError::HandoffDisappeared)?;
    let envelope = crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s421_reconciled_s187_handoff_delivery::take_s421_reconciled_s187_handoff_on_cpu1()
        .map_err(G8lS423ProductionS187ContinuationError::S421)?
        .ok_or(G8lS423ProductionS187ContinuationError::HandoffDisappeared)?;
    if envelope.view() != view {
        return Err(G8lS423ProductionS187ContinuationError::HandoffDrift);
    }
    let handoff = envelope.into_handoff();
    unsafe {
        crate::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s186_mapping_retirement::publish_runtime_owner_tuple_from_production_s187_handoff(handoff)
    }.map_err(G8lS423ProductionS187ContinuationError::Consumer)?;
    Ok(G8lS423S187ContinuationOutcome::Invoked(
        G8lS423S187ContinuationReceipt::from_preflight(preflight),
    ))
}

use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s242_authority_return_s240_receipt_deferred_consumer::G8lS243DeferredS187HandoffSlot;
use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s419_handshake_terminal_journal::{service_s419_model_handshake_terminal_journal, G8lS419HandshakeTerminalJournalState, G8lS419HandshakeTerminalKind};
use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s420_terminal_reconciliation_ack::{service_s420_model_terminal_reconciliation_ack, G8lS420TerminalReconciliationAckState};
use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s421_reconciled_s187_handoff_delivery::{service_s421_model_reconciled_s187_handoff_delivery, G8lS421ReconciledS187HandoffState};
use aselsan_microkernel_simulation::g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s423_s187_continuation_invocation::*;

fn delivered(value: u64) -> G8lS421ReconciledS187HandoffState<u64> {
    let mut journal = G8lS419HandshakeTerminalJournalState::new();
    service_s419_model_handshake_terminal_journal(
        &mut journal,
        1,
        G8lS419HandshakeTerminalKind::Completed,
        7,
        8,
        9,
        3,
    )
    .unwrap();
    let mut acks = G8lS420TerminalReconciliationAckState::new();
    service_s420_model_terminal_reconciliation_ack(&mut journal, &mut acks, 0, None, true, true)
        .unwrap();
    let mut s243 = G8lS243DeferredS187HandoffSlot::new();
    s243.publish(value).unwrap();
    let mut state = G8lS421ReconciledS187HandoffState::new();
    service_s421_model_reconciled_s187_handoff_delivery(&mut acks, &mut s243, &mut state, 1)
        .unwrap();
    state
}

#[test]
fn constants_promote_exactly_one_real_continuation_callsite() {
    assert_eq!(S423_PRODUCTION_S187_CONTINUATION_CALLSITES, 1);
    assert!(S423_S187_CONTINUATION_INVOCATION_COMPLETE);
    assert!(S423_S223_TO_S212_SOURCE_CHAIN_REACHED);
    assert!(!S423_SUPPORTED_PROFILE_RUNTIME_OBSERVATION_COMPLETE);
}

#[test]
fn exact_envelope_is_consumed_once_by_continuation() {
    let mut state = delivered(41);
    let mut observed = None;
    let outcome =
        service_s423_model_s187_continuation_invocation(&mut state, 1, None, true, |handoff| {
            observed = Some(handoff);
            Ok::<(), ()>(())
        })
        .unwrap();
    let G8lS423S187ContinuationOutcome::Invoked(receipt) = outcome else {
        panic!("invoked")
    };
    assert_eq!(observed, Some(41));
    assert_eq!(
        (
            receipt.attempt_id(),
            receipt.provider_request_id(),
            receipt.exclusive_token()
        ),
        (7, 8, 9)
    );
    assert!(receipt.s223_to_s212_chain_entered());
    assert!(!state.pending());
}

#[test]
fn absent_envelope_is_idle_without_consumer() {
    let mut state = G8lS421ReconciledS187HandoffState::<u64>::new();
    assert_eq!(
        service_s423_model_s187_continuation_invocation(
            &mut state,
            1,
            None,
            true,
            |_| -> Result<(), ()> { panic!("idle") }
        )
        .unwrap(),
        G8lS423S187ContinuationOutcome::Idle
    );
}

#[test]
fn consumer_error_is_terminal_after_handoff_take() {
    let mut state = delivered(41);
    assert_eq!(
        service_s423_model_s187_continuation_invocation(
            &mut state,
            1,
            None,
            true,
            |_| Err::<(), _>("downstream")
        ),
        Err(G8lS423S187ContinuationError::Consumer("downstream"))
    );
    assert!(!state.pending());
}

#[test]
fn failed_preflight_preserves_envelope() {
    let mut state = delivered(41);
    assert!(matches!(
        service_s423_model_s187_continuation_invocation(&mut state, 1, Some(9), true, |_| Ok::<
            (),
            (),
        >(
            ()
        )),
        Err(G8lS423S187ContinuationError::S422(_))
    ));
    assert!(state.pending());
}

#[test]
fn model_orders_preflight_take_binding_check_into_handoff_then_consumer() {
    let source = include_str!("../../kernel/src/g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s423_s187_continuation_invocation.rs");
    let start = source
        .find("service_s423_model_s187_continuation_invocation")
        .unwrap();
    let body: String = source[start..].split_whitespace().collect();
    let preflight = body.find("preflight_s422_s187_continuation").unwrap();
    let take = body.find("delivered.take(caller_cpu)").unwrap();
    let check = body.find("envelope.view()!=view").unwrap();
    let unwrap = body.find("envelope.into_handoff()").unwrap();
    let consume = body.find("consume(handoff)").unwrap();
    assert!(preflight < take && take < check && check < unwrap && unwrap < consume);
}

#[test]
fn production_invokes_exact_existing_s187_handoff_consumer() {
    let source = include_str!("../../kernel/src/g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s423_s187_continuation_invocation.rs");
    let start = source
        .find("service_s423_s187_continuation_invocation_on_cpu1")
        .unwrap();
    let body = &source[start..];
    let preflight = body
        .find("service_s422_s187_continuation_preflight_on_cpu1")
        .unwrap();
    let take = body
        .find("take_s421_reconciled_s187_handoff_on_cpu1")
        .unwrap();
    let invoke = body
        .find("publish_runtime_owner_tuple_from_production_s187_handoff")
        .unwrap();
    assert!(preflight < take && take < invoke);
    assert_eq!(
        body.matches("publish_runtime_owner_tuple_from_production_s187_handoff")
            .count(),
        1
    );
}

#[test]
fn timer_chain_invokes_s423_after_s421_before_s417() {
    let source = include_str!("../../kernel/src/arch/aarch64/exceptions.rs");
    let s421 = source
        .find("service_s421_reconciled_s187_handoff_delivery_on_cpu1")
        .unwrap();
    let s423 = source
        .find("service_s423_s187_continuation_invocation_on_cpu1")
        .unwrap();
    let s417 = source
        .find("service_s417_handshake_attempt_reconciliation_on_cpu1")
        .unwrap();
    assert!(s421 < s423 && s423 < s417);
    let name = "g8l_target_dispatch_scheduler_owner_scheduler_mutation_production_migration_lifecycle_s423_s187_continuation_invocation";
    assert!(include_str!("../../kernel/src/main.rs").contains(&format!("mod {name};")));
    assert!(include_str!("../src/lib.rs").contains(&format!("pub mod {name};")));
}

  {
    id: "g8l-s423-s187-continuation-invocation-partial",
    sequence: 423,
    slug: "s187_continuation_invocation",
    title: "S187 continuation invocation",
    focusedTests: 8,
    sourceBytes: 7159,
    sourceSha256:
      "e325ddad8b9ae62e635cd4269aac4119c5356da9fdbfd7ff875748d8fdb20ba7",
    testBytes: 6738,
    testSha256:
      "477569e02f1e3835a33dea79b30b0fb71b888f32cba39e49668914203eedeb29",
    acceptance:
      "CPU1 S422 preflight sonrası exact non-Copy S187 handoff'u one-shot alıp mevcut S223→S212 migration-lifecycle continuation zincirine verir.",
    retainedBoundary:
      "Source chain reached olsa da supported-profile runtime observation henüz kabul kanıtı değildir.",
  },