Struct LatentTailCapture 

pub struct LatentTailCapture {
    pub len: usize,
    pub width: usize,
    pub index_width: usize,
    pub index_pool: usize,
    pub index_pools_ready: usize,
    pub index_tail: Option<CudaSlice<f32>>,
}

The generation-destroyed slice of one latent layer’s BOUNDARY state, captured EAGERLY at a spec session’s prompt boundary (lane/glm5-prefix-latent2, 2026-09-01) so a DEFERRED prefix publication can be completed later against the live plane:

• the latent rows and the FINAL pool keys are append-only BELOW the boundary for the session’s lifetime (the glm5 verify rollback truncates back to the accepted length, never below the prime boundary), so snapshot_plane_at slices them from the LIVE layer at publish time — no eager copy of the big planes;
• the incomplete tail-ring rows are read-once and OVERWRITTEN by the very next pool build, so they travel HERE or the boundary is unrecoverable by publish time (the KDA conv/ssm half of the same problem rides the sibling CacheSnapshot).

Fields

len: usize

Boundary length (== capture pos) — the row count the deferred publisher slices.

width: usize

Latent width at capture; the publish-time slice validates it against the live layer.

index_width: usize

index_pool: usize

The indexer’s pool size at capture (0 iff no indexer plane).

index_pools_ready: usize

len / pool at the boundary (the capture asserts the drain invariant, same as snapshot_plane).

index_tail: Option<CudaSlice<f32>>

The live tail-ring rows [pools_ready * pool, len) at the boundary, (len % pool) * index_width f32; None when the boundary is pool-aligned (or the layer has no indexer).

Implementations

impl LatentTailCapture

pub fn bytes(&self) -> usize

Device bytes held eagerly (the tail only — the big planes are sliced at publish).