Struct PluginTreeHead 

pub struct PluginTreeHead<I: InterfaceData, P: PluginData + 'static> { /* private fields */ }

The root node of a loaded plugin tree.

Obtained from PluginTree::load. This is the host application’s entry point for calling into the plugin system. The root socket represents the interface that the host has access to - all other interfaces are internal and can only be called by other plugins.

The host acts as a pseudo-plugin: it doesn’t need to be implemented in WASM and has access to system capabilities that plugins don’t.

Implementations

impl<I: InterfaceData, P: PluginData> PluginTreeHead<I, P>

pub fn dispatch( &self, interface_path: &str, function: &str, has_return: bool, data: &[Val], ) -> Socket<Result<Val, DispatchError<I>>, P::Id>

Invokes a function on all plugins in the root socket.

Dispatches the function call to every plugin implementing the root interface. The return type is a Socket whose variant matches the interface’s cardinality:

• ExactlyOne cardinality → Socket::ExactlyOne(result)
• AtMostOne cardinality → Socket::AtMostOne(Option<result>)
• AtLeastOne / Any cardinality → Socket::AtLeastOne/Any(HashMap<PluginId, result>)

Arguments

• interface_path - Full WIT interface path (e.g., "my:package/interface-name")
• function - Function name to call as declared in the interface
• has_return - Whether you expect to receive a return value
• data - Arguments to pass to the function as wasmtime Vals

Example

use wasm_link::{
    InterfaceData, InterfaceCardinality, FunctionData, ReturnKind,
    PluginData, PluginCtxView, PluginTree, Socket, 
    Engine, Component, Linker, ResourceTable, Val,
};

#[derive( Clone )]
struct Func { name: String, return_kind: ReturnKind }
impl FunctionData for Func {
    /* .. */
}

struct Interface { id: &'static str, funcs: Vec<Func> }
impl InterfaceData for Interface {
    /* ... */
}

struct Plugin { id: &'static str, plug: &'static str, resource_table: ResourceTable }
impl PluginData for Plugin {
    /* ... */
}

let root_interface_id = "root" ;
let plugins = [ Plugin { id: "foo", plug: root_interface_id, resource_table: ResourceTable::new() }];
let interfaces = [ Interface { id: root_interface_id, funcs: vec![
    Func { name: "get-value".to_string(), return_kind: ReturnKind::MayContainResources }
]}];

let ( tree, build_errors ) = PluginTree::new( root_interface_id, interfaces, plugins );
assert!( build_errors.is_empty() );

let engine = Engine::default();
let linker = Linker::new( &engine );
let ( tree_head, load_errors ) = tree.load( &engine, &linker ).unwrap();
assert!( load_errors.is_empty() );

// Dispatch returns a Socket matching the interface's cardinality
let result = tree_head.dispatch( "my:package/example", "get-value", true, &[] );

match result {
    Socket::ExactlyOne( Ok( Val::U32( n ))) => assert_eq!( n, 42 ),
    Socket::ExactlyOne( Err( e )) => panic!( "dispatch error: {e}" ),
    _ => panic!( "unexpected cardinality" ),
}