// NEW immutable layout/ownership observation appended only to generated Queue.
// No Member, Prepared, backend loan or release authority escapes.
impl<B: QueueCompletionBackend, const N: usize> ReturnQueue<B, N> {
    pub fn os_k1060_owner_words(&self) -> [u64; 16] {
        let q = &self.queue.queue;
        let p = self.pending.as_ref();
        [
            q.identity,
            q.cpu as u64,
            q.epoch,
            q.active.map_or(0, |i| i as u64 + 1),
            u64::from(q.faulted),
            q.total_ticks,
            q.len as u64,
            self.sequence,
            p.map_or(0, |p| {
                p as *const PendingQueueReturn<B::ReturnPrepared> as u64
            }),
            p.map_or(0, |p| p.nonce),
            p.map_or(0, |p| {
                if p.stage == QueueReturnStage::Staged {
                    1
                } else {
                    2
                }
            }),
            p.map_or(0, |p| p.source as u64),
            p.map_or(0, |p| p.generation),
            p.map_or(0, |p| &p.prepared as *const B::ReturnPrepared as u64),
            core::mem::size_of::<Self>() as u64,
            u64::from(self.quarantined),
        ]
    }
    pub fn os_k1060_member_words(&self) -> [[u64; 16]; N] {
        let q = &self.queue.queue;
        core::array::from_fn(|i| {
            let e = &q.entries[i];
            [
                i as u64,
                e.generation,
                e.member
                    .as_ref()
                    .map_or(0, |m| m as *const B::Member as u64),
                e.thread.map_or(0, |t| t.table()),
                e.thread.map_or(0, |t| t.slot() as u64),
                e.thread.map_or(0, |t| t.generation()),
                if e.class == Class::Normal { 0 } else { 1 },
                e.remaining as u64,
                e.slice,
                e.consumed_ticks,
                e.slices,
                u64::from(q.ready[..q.len].contains(&i)),
                u64::from(q.active == Some(i)),
                &q.backend as *const B as u64,
                core::mem::size_of::<B::Member>() as u64,
                core::mem::size_of::<B>() as u64,
            ]
        })
    }
}
pub const fn os_k1060_return_layout<B: QueueCompletionBackend, const N: usize>() -> [u64; 40] {
    use core::mem::{offset_of, size_of};
    [
        size_of::<ReturnQueue<B, N>>() as u64,
        offset_of!(ReturnQueue<B,N>,queue) as u64,
        offset_of!(ReturnQueue<B,N>,sequence) as u64,
        offset_of!(ReturnQueue<B,N>,pending) as u64,
        offset_of!(ReturnQueue<B,N>,quarantined) as u64,
        size_of::<AsyncQueue<B, N>>() as u64,
        offset_of!(AsyncQueue<B,N>,queue) as u64,
        offset_of!(AsyncQueue<B,N>,sequence) as u64,
        offset_of!(AsyncQueue<B,N>,pending) as u64,
        offset_of!(AsyncQueue<B,N>,quarantined) as u64,
        size_of::<Queue<B, N>>() as u64,
        offset_of!(Queue<B,N>,backend) as u64,
        offset_of!(Queue<B,N>,identity) as u64,
        offset_of!(Queue<B,N>,cpu) as u64,
        offset_of!(Queue<B,N>,entries) as u64,
        offset_of!(Queue<B,N>,ready) as u64,
        offset_of!(Queue<B,N>,len) as u64,
        offset_of!(Queue<B,N>,active) as u64,
        offset_of!(Queue<B,N>,epoch) as u64,
        offset_of!(Queue<B,N>,total_ticks) as u64,
        offset_of!(Queue<B,N>,faulted) as u64,
        size_of::<Entry<B::Member>>() as u64,
        offset_of!(Entry<B::Member>, generation) as u64,
        offset_of!(Entry<B::Member>, member) as u64,
        offset_of!(Entry<B::Member>, thread) as u64,
        offset_of!(Entry<B::Member>, class) as u64,
        offset_of!(Entry<B::Member>, remaining) as u64,
        offset_of!(Entry<B::Member>, slice) as u64,
        offset_of!(Entry<B::Member>, consumed_ticks) as u64,
        offset_of!(Entry<B::Member>, slices) as u64,
        size_of::<PendingQueueReturn<B::ReturnPrepared>>() as u64,
        offset_of!(PendingQueueReturn<B::ReturnPrepared>, nonce) as u64,
        offset_of!(PendingQueueReturn<B::ReturnPrepared>, source) as u64,
        offset_of!(PendingQueueReturn<B::ReturnPrepared>, generation) as u64,
        offset_of!(PendingQueueReturn<B::ReturnPrepared>, epoch) as u64,
        offset_of!(PendingQueueReturn<B::ReturnPrepared>, prepared) as u64,
        offset_of!(PendingQueueReturn<B::ReturnPrepared>, stage) as u64,
        size_of::<B::ReturnPrepared>() as u64,
        size_of::<B::Member>() as u64,
        N as u64,
    ]
}