Enum Expiry 

pub enum Expiry {
    Never,
    AtUnix(u64),
    EndOfSession,
    AfterUse,
}

When a capability dies — the expiry of (subject, resource, verbs, expiry).

The whole lifetime vocabulary: the portal’s “Just once” / “Until I log out” / “Always” map to Expiry::AfterUse, EndOfSession and Never respectively, not a parallel enum.

Variants

Never

Lives until explicitly revoked, and survives a restart.

AtUnix(u64)

Dies at this wall-clock instant (seconds since epoch); survives a restart if not yet past.

EndOfSession

Dies when the granting session ends. Never written to disk.

AfterUse

Dies as soon as the requesting prompt completes. Never written to disk.

Implementations

impl Expiry

pub fn is_live_at(self, now: Option<u64>) -> bool

Is a capability with this expiry still live at now?

now: None skips time evaluation — used by the wire validator, which shares no clock with an op’s author. EndOfSession/AfterUse are live here; their deaths are events (not persisting, dropping after use), not instants.

pub fn persists_across_restart(self) -> bool

Should a capability with this expiry be written to disk?

The single answer to “does Always survive a restart?” — session- and use-scoped capabilities are excluded so persisting them can’t silently turn a one-shot grant into a permanent one.

pub fn outlives(self, other: Expiry) -> bool

Does a capability with this expiry outlive one with other?

Order: Never > AtUnix(later) > AtUnix(earlier) > EndOfSession > AfterUse. An explicit deadline outranks the session because it survives a restart.

pub fn longest(a: Expiry, b: Expiry) -> Expiry

The longer-lived of two expiries — the single definition of “strongest scope wins”, used both merging a re-grant and reporting an existing grant’s strength. Two answers here would eventually disagree, reading as a permanent grant silently becoming a session one.

Trait Implementations

impl Clone for Expiry

fn clone(&self) -> Expiry

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Expiry

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for Expiry

fn default() -> Expiry

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Expiry

fn deserialize<__D>( __deserializer: __D, ) -> Result<Expiry, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Expiry

fn eq(&self, other: &Expiry) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Expiry

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Expiry

impl Eq for Expiry

impl StructuralPartialEq for Expiry