Struct Surface 

pub struct Surface {

    pub id: String,
    pub title: String,
    pub category: Category,
    pub visibility: Visibility,
    pub kind: SurfaceKind,
    pub mount: Mount,
    pub producer: String,
    pub feature: Option<Feature>,
    pub artifact: Option<PathBuf>,
    pub index: Option<String>,
    pub availability: Availability,
    pub built_from: Option<String>,
    pub provenance: BTreeMap<String, Provenance>,
}

One resolved surface: everything a consumer needs, with the provenance of what it could be surprised by.

Fields

id: String

Identity, unique across the topology; the selector --only and --exclude use it.

title: String

One line: what a reader sees in a listing.

category: Category

What it is for, which is how a listing groups it.

visibility: Visibility

Whether a person is shown it.

kind: SurfaceKind

How it answers.

mount: Mount

Where it answers.

producer: String

What produced it: a command, a module, or the generator that writes the directory.

feature: Option<Feature>

The runtime capability it needs; absent when the process always has it.

artifact: Option<PathBuf>

The generated directory, repository-relative, for a static surface.

index: Option<String>

The file served for the mount itself, when the surface has one.

availability: Availability

Where the surface’s files go and who answers for it.

built_from: Option<String>

The revision the artifact was built from, when its producer recorded one: what makes a stale build a finding rather than a surprise.

provenance: BTreeMap<String, Provenance>

Where each interesting value came from, by field name.

Implementations

impl Surface

pub fn publishes(&self) -> bool

Does this surface put files into a publication?

pub fn served_by(&self, runtime: Runtime) -> bool

Does a process with these runtime capabilities answer for this surface?

use majordomus_cli::web::discover::Runtime;
use majordomus_cli::web::model::Feature;
let mut s = Surface { id: "mcp".into(), title: "MCP".into(), category: Category::Protocol,
    visibility: Visibility::Internal, kind: SurfaceKind::NativeRoute,
    mount: Mount::parse("/mcp").unwrap(), producer: "t".into(), feature: Some(Feature::Mcp),
    artifact: None, index: None, availability: Availability::ServedOnly,
    built_from: None, provenance: BTreeMap::new() };
assert!(s.served_by(Runtime::full()));
assert!(!s.served_by(Runtime::default()));
s.feature = None;
assert!(s.served_by(Runtime::default()));

Trait Implementations

impl Clone for Surface

fn clone(&self) -> Surface

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Surface

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Surface

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Surface

impl JsonSchema for Surface

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Ordered for Surface

A surface is presented by its id: the composition writes its artifact under that name, the topology reports it under that name, and the title is prose.

fn order_key(&self) -> OrderKey<'_>

The four parts this item is ordered by. Borrowed from the item: building a key allocates nothing, so sorting a large collection costs the comparisons and no more.

impl PartialEq for Surface

fn eq(&self, other: &Surface) -> 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 Surface

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Surface