// NEW main-only endpoints appended to the separately named copied Bridge.
// No Queue/Bank/Table reference or mutable observer escapes an endpoint.
pub enum K1080MainReturnFailure {
    Before(wait::Error, queue::OwnedQueueReturn),
    After(wait::Error, queue::OwnedQueueReturn),
    Quarantined(wait::Error),
}
fn os_k1080_return_failure(e: queue::QueueReturnFailure) -> K1080MainReturnFailure {
    match e {
        queue::QueueReturnFailure::Before(_, t) => {
            K1080MainReturnFailure::Before(wait::Error::Backend, t)
        }
        queue::QueueReturnFailure::Quarantined(_) => {
            K1080MainReturnFailure::Quarantined(wait::Error::Quarantined)
        }
    }
}
fn os_k1080_full_gate(e: context::Execution) -> Result<(), wait::Error> {
    if e.cpu != 0
        || e.daif & 128 == 0
        || e.daif & !0x3c0 != 0
        || e.in_irq
        || !e.fp_enabled
        || e.critical_depth != 0
        || !e.safe_point
    {
        return Err(wait::Error::Context);
    }
    Ok(())
}
/// # Safety
/// Execution is a pure actual CPU/DAIF/root/SP/FP/scope/current observation;
/// it never borrows Table/stack/allocator or substitutes a desired target.
/// Wire callbacks read only the same exclusively retained Prepared. They do
/// not branch across a loan or mutate a resource. The caller independently
/// compares the full actual Execution before and after every callback.
pub unsafe trait K1080MainBackend:
    queue::QueueCompletionBackend + queue::WaitQueueServices
{
    fn k1080_execution(&self) -> context::Execution;
    fn k1080_target_wire(&self, p: &Self::Prepared) -> Result<(context::Image, u64), wait::Error>;
    fn k1080_bootstrap_wire(
        &self,
        p: &Self::ReturnPrepared,
    ) -> Result<context::Cooperative, wait::Error>;
}
impl<B: K1080MainBackend, A: WaitAuthority> WaitGuestBridge<B, A> {
    pub const fn os_k1080_queue_offset() -> u64 {
        core::mem::offset_of!(Self, queue) as u64
    }
    pub fn os_k1080_cleanup_ready(&self) -> Result<(), wait::Error> {
        let e = self.gate()?;
        if e.current.is_some()
            || self.retained_claims() != 0
            || self.retained_failure()
            || self.departed_handle.is_some()
            || self.departed_target.is_some()
            || self.queue.return_stage().is_some()
        {
            return Err(wait::Error::Pending);
        }
        let snapshot = self.queue.queue().snapshot();
        if snapshot.active != 0 || snapshot.members != 0 || snapshot.queued != 0 {
            return Err(wait::Error::Pending);
        }
        self.queue.queue().audit().map_err(|_| wait::Error::State)
    }
    pub fn os_k1080_raw_execution(&self) -> wait::Execution {
        self.authority.execution()
    }
    /// Pure inert receipt of the genuinely retained failed lookup. This reads
    /// no backend, Table or stack and grants no retry or completion authority.
    pub fn os_k1080_retained_selection_nonce(&self) -> Option<u64> {
        self.failed_selection.as_ref().map(|actual| actual.nonce())
    }
    pub fn os_k1080_landing_bounds(
        &self,
    ) -> Result<crate::runtime::wait_threads::StackLayout, wait::Error> {
        let e = self.authority.execution();
        wait::context(0, e, wait::Operation::Service)?;
        if self.faulted || self.queue.quarantined() {
            return Err(wait::Error::Quarantined);
        }
        let before = self
            .queue
            .queue()
            .with_backend_observation(|b| b.k1080_execution());
        os_k1080_full_gate(before)?;
        let h = self.departed_handle.ok_or(wait::Error::State)?;
        let o = self
            .queue
            .queue()
            .wait_guest_observe(h)
            .map_err(|_| wait::Error::State)?;
        if self
            .queue
            .queue()
            .with_backend_observation(|b| b.k1080_execution())
            != before
            || self.authority.execution() != e
        {
            return Err(wait::Error::Context);
        }
        if Some(o.thread.id) != self.departed_target || o.thread.state != State::Ready {
            return Err(wait::Error::State);
        }
        Ok(o.thread.layout)
    }
    pub fn os_k1080_thread(&self, ordinal: usize) -> Result<ThreadId, wait::Error> {
        self.gate()?;
        let h = *self.handles.get(ordinal).ok_or(wait::Error::State)?;
        self.queue
            .queue()
            .record(h)
            .map(|r| r.thread)
            .map_err(|_| wait::Error::Stale)
    }
    pub fn os_k1080_main_select(&mut self) -> Result<queue::OwnedSelection, wait::Error> {
        let before = self.gate()?;
        let actual = self
            .queue
            .select(queue::Disposition::Ready)
            .map_err(|_| wait::Error::Backend)?;
        if self.trusted_execution() != before {
            self.failed_selection = Some(actual);
            self.faulted = true;
            return Err(wait::Error::Quarantined);
        }
        Ok(actual)
    }
    pub fn os_k1080_main_depart(
        &mut self,
        actual: queue::OwnedSelection,
    ) -> Result<(queue::OwnedSelection, context::Image, u64), queue::HandoffSelectionError> {
        if let Err(e) = self.gate() {
            return Err(queue::HandoffSelectionError::Before(
                if e == wait::Error::Quarantined {
                    queue::Error::Quarantined
                } else {
                    queue::Error::Context
                },
                actual,
            ));
        }
        let target = match self.queue.target(&actual) {
            Ok(h) => h,
            Err(e) => return Err(queue::HandoffSelectionError::Before(e, actual)),
        };
        let thread = match self.queue.queue().record(target) {
            Ok(r) => r.thread,
            Err(e) => return Err(queue::HandoffSelectionError::Before(e, actual)),
        };
        let actual = self.queue.depart(actual)?;
        self.departed_handle = Some(target);
        self.departed_target = Some(thread);
        // Physical SP is still the source. The trusted execution deliberately
        // remains current=None until the actual landing callback proves it.
        match self.os_k1080_retained_wire() {
            Ok((image, nonce)) => Ok((actual, image, nonce)),
            Err(_) => {
                self.failed_selection = Some(actual);
                self.faulted = true;
                Err(queue::HandoffSelectionError::Quarantined(
                    queue::Error::Backend,
                ))
            }
        }
    }
    pub fn os_k1080_retained_wire(&self) -> Result<(context::Image, u64), wait::Error> {
        let e = self.authority.execution();
        wait::context(0, e, wait::Operation::Service)?;
        if self.faulted || self.queue.quarantined() {
            return Err(wait::Error::Quarantined);
        }
        let before = self
            .queue
            .queue()
            .with_backend_observation(|b| b.k1080_execution());
        os_k1080_full_gate(before)?;
        if before.thread.is_some() {
            return Err(wait::Error::Context);
        }
        let result = self.queue.queue().with_retained_observation(|p| {
            self.queue
                .queue()
                .with_backend_observation(|b| b.k1080_target_wire(p.ok_or(wait::Error::State)?))
        });
        if self
            .queue
            .queue()
            .with_backend_observation(|b| b.k1080_execution())
            != before
            || self.authority.execution() != e
        {
            return Err(wait::Error::Context);
        }
        result
    }
    pub fn os_k1080_main_landed(
        &mut self,
        actual: queue::OwnedSelection,
    ) -> Result<queue::Handle, queue::HandoffSelectionError> {
        let observed = match self.gate() {
            Ok(e) => e,
            Err(_) => {
                return Err(queue::HandoffSelectionError::Before(
                    queue::Error::Context,
                    actual,
                ));
            }
        };
        if observed.current != self.departed_target || observed.current.is_none() {
            return Err(queue::HandoffSelectionError::Before(
                queue::Error::Context,
                actual,
            ));
        }
        let result = self.queue.landed(actual)?;
        self.departed_target = None;
        self.departed_handle = None;
        if self.gate().is_err() {
            self.faulted = true;
            return Err(queue::HandoffSelectionError::Quarantined(
                queue::Error::Context,
            ));
        }
        Ok(result)
    }
    pub fn os_k1080_main_return(
        &mut self,
        capture: context::Capture,
    ) -> Result<queue::OwnedQueueReturn, wait::Error> {
        self.gate()?;
        self.queue
            .prepare_return(capture)
            .map_err(|_| wait::Error::Backend)
    }
    pub fn os_k1080_main_return_depart(
        &mut self,
        token: queue::OwnedQueueReturn,
    ) -> Result<(queue::OwnedQueueReturn, context::Cooperative), K1080MainReturnFailure> {
        if self.gate().is_err() {
            return Err(K1080MainReturnFailure::Before(wait::Error::Context, token));
        }
        let token = self
            .queue
            .depart_return(token)
            .map_err(os_k1080_return_failure)?;
        let observed = self.authority.execution();
        let before = self
            .queue
            .queue()
            .with_backend_observation(|b| b.k1080_execution());
        if wait::context(0, observed, wait::Operation::Service).is_err()
            || os_k1080_full_gate(before).is_err()
            || before.thread.is_some()
        {
            self.faulted = true;
            return Err(K1080MainReturnFailure::After(wait::Error::Context, token));
        }
        let result = self.queue.with_return_observation(|p| {
            self.queue
                .queue()
                .with_backend_observation(|b| b.k1080_bootstrap_wire(p.ok_or(wait::Error::State)?))
        });
        if self
            .queue
            .queue()
            .with_backend_observation(|b| b.k1080_execution())
            != before
            || self.authority.execution() != observed
        {
            self.faulted = true;
            return Err(K1080MainReturnFailure::After(wait::Error::Context, token));
        }
        match result {
            Ok(f) => Ok((token, f)),
            Err(_) => {
                self.faulted = true;
                // Retain the actual lookup after the genuine departure; this
                // is an After failure and never authorizes abort/retry.
                Err(K1080MainReturnFailure::After(wait::Error::Backend, token))
            }
        }
    }
    pub fn os_k1080_main_return_landed(
        &mut self,
        token: queue::OwnedQueueReturn,
    ) -> Result<(), K1080MainReturnFailure> {
        let e = self.authority.execution();
        if wait::context(0, e, wait::Operation::Service).is_err() || e.current.is_some() {
            return Err(K1080MainReturnFailure::Before(wait::Error::Context, token));
        }
        self.queue
            .return_landed(token)
            .map_err(os_k1080_return_failure)
    }
}
impl<B: K1080MainBackend + queue::QueueRetirementBackend, A: WaitAuthority> WaitGuestBridge<B, A> {
    pub fn os_k1080_main_retire(
        &mut self,
        ordinal: usize,
    ) -> Result<(), (wait::Error, Option<B::Member>)> {
        self.gate().map_err(|e| (e, None))?;
        if self.retained_claims() != 0
            || self.retained_failure()
            || self.departed_handle.is_some()
            || self.departed_target.is_some()
            || self.queue.return_stage().is_some()
        {
            return Err((wait::Error::Pending, None));
        }
        let handle = *self
            .handles
            .get(ordinal)
            .ok_or((wait::Error::State, None))?;
        let q = self
            .queue
            .quiescent()
            .map_err(|_| (wait::Error::Pending, None))?;
        let actual = q
            .withdraw(handle)
            .map_err(|_| (wait::Error::Backend, None))?;
        q.os_k1080_retire_withdrawn(actual)
            .map_err(|(_, actual)| (wait::Error::Backend, Some(actual)))
    }
}