Struct ComponentManifest 

pub struct ComponentManifest {
    pub id: ModuleId,
    pub description: Option<String>,
    pub exports: InterfaceList,
    pub imports: InterfaceList,
    pub capabilities: ComponentCapabilities,
}

A portable, human-readable descriptor of a WebAssembly component.

The manifest captures what a component is, what it provides, and what it needs — independently of any specific runtime. It serves three key purposes:

1. Identity: id (name@version) uniquely identifies the component.
2. Contract: imports and exports define its interface boundary (like a WIT package).
3. Intent: capabilities express environmental requirements (WASI, FS, network, etc.).

This structure supports three input formats during deserialization:

• String: "name@version" (e.g., in deployment specs)
• Flat object: { "name": "...", "version": "...", ... } (e.g., in component.toml)
• Nested object: { "id": { "name": "...", "version": "..." }, ... } (e.g., in JSON state snapshots)

Fields

id: ModuleId

Canonical, validated identifier of the component: name@version.

description: Option<String>

Optional short description for documentation or tooling.

exports: InterfaceList

Interfaces this component provides to others.

Each key must be a valid WIT-style interface name:

• With version: "logger:log@1.0"
• Without version: "my:custom"

Values are structured interface specs (e.g., ComponentInstance trees). When loaded from a simple config (e.g., TOML array), they default to Unknown.

imports: InterfaceList

Interfaces this component requires from its environment.

Same format as exports. These must be satisfied at link time by:

• The runtime (e.g., wasi:cli/stdio),
• Other deployed components (e.g., "auth:validator@1.0").

capabilities: ComponentCapabilities

Runtime capabilities and resource requirements.

Used by the Arcella executor to:

• Grant minimal required permissions,
• Enforce sandboxing,
• Allocate resources safely.

Implementations

impl ComponentManifest

pub fn validate(&self) -> ArcellaTypeResult<()>

Validates the semantic correctness of the entire manifest.

Since id is a ModuleId, name and version are already valid. This method only checks interface formats.

pub fn validate_interface_format(s: &str) -> bool

Checks if a string matches the expected WIT interface reference format.

Two forms are accepted:

• With version: namespace:interface@version (e.g., wasi:http@0.2.0)
• Without version: namespace:interface (e.g., my:custom)

Interface part may contain / for nested paths (e.g., wasi:cli/stdio).

Trait Implementations

impl Clone for ComponentManifest

fn clone(&self) -> ComponentManifest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ComponentManifest

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ComponentManifest

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ComponentManifest

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ComponentManifest

impl StructuralPartialEq for ComponentManifest