Struct Capability 

pub struct Capability {

    pub operation: Operation,
    pub locus: Locus,
    pub scale: Scale,
    pub retrieval: RetrievalGranularity,
    pub authority: Authority,
    pub isolation: Isolation,
    pub reversibility: Reversibility,
    pub persistence: Persistence,
    pub disclosure: Disclosure,
    pub secret: Secret,
    pub network: Network,
    pub execution: Execution,
    pub cost: Cost,
    pub because: String,
}

One capability — a single point in facet-space (v1.4 §2.8). Facets left unset default to their zero term. because cites the discriminator (§5); the nested delegate profile and supply-chain sub-facets arrive with the mechanisms that need them.

Fields

operation: Operation

locus: Locus

scale: Scale

retrieval: RetrievalGranularity

authority: Authority

isolation: Isolation

reversibility: Reversibility

persistence: Persistence

disclosure: Disclosure

secret: Secret

network: Network

execution: Execution

cost: Cost

because: String

Implementations

impl Capability

pub fn new(operation: Operation) -> Self

A capability performing operation, every other facet at its zero term.

pub fn set_facets(&self) -> Vec<(&'static str, &'static str)>

The facets this capability actually SETS, as (dotted name, term) pairs.

Only non-default terms: a capability is a point in 27-dimensional space and almost all of those dimensions sit at their zero term, so printing every one buries the four or five that characterize it. because carries the prose; this carries the point.

pub fn worst(because: impl Into<String>) -> Self

A maximally-severe capability — every axis at its declared hazard, so no level whose job is to deny admits it. yolo DOES admit it, which is that level’s whole meaning: a user who selects “auto-approve everything” has opted out of the question this sentinel answers.

Derived from FacetTerm::hazard rather than hand-written. The hand-written version drifted on two axes — persistence.trigger.kind sat at none (“not recurring”, the BENIGN case) and the supply chain was absent, which satisfies every supply-chain constraint vacuously on an allow clause. Neither was exploitable, because the denial rested on locus.local = kernel; that it rested on a single axis at all is what the_sentinel_is_denied_even_with_any_one_axis_relaxed now forbids. The resolver returns this when it cannot certify something (§0), keeping the engine from being looser than a strict classifier on a form it doesn’t understand. Ordinal worsts are the ladder tops; categorical worsts are the hazardous term (Channel::Unknown, Principal::Cross).

Trait Implementations

impl Clone for Capability

fn clone(&self) -> Capability

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Capability

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

Formats the value using the given formatter.

impl Default for Capability

fn default() -> Capability

Returns the “default value” for a type.

impl Eq for Capability

impl Hash for Capability

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Capability

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Capability