Rust Multi-Surface Architecture — Implementation Blueprint

core/
 ├─ Cargo.toml
 ├─ src/
 │   ├─ domain/
 │   ├─ services/
 │   ├─ ports/
 │   ├─ plugin_api/
 │   ├─ errors.rs
 │   └─ lib.rs

#[async_trait::async_trait]
pub trait Storage: Send + Sync {
    async fn save(&self, item: Project) -> Result<()>;
}

interface/
 ├─ dto/
 ├─ mapping/
 ├─ schema/
 └─ lib.rs

#[derive(Serialize, Deserialize)]
pub struct ProjectDto {
    pub id: String,
    pub name: String,
}

impl From<Project> for ProjectDto {
    fn from(p: Project) -> Self {
        Self { id: p.id.to_string(), name: p.name }
    }
}

#[async_trait::async_trait]
pub trait RequestHandler {
    async fn handle(&self, req: Payload) -> Result<Payload>;
}

pub trait Transport {
    fn start(self) -> Result<()>;
}

serde-strategy/
 ├─ json.rs
 ├─ msgpack.rs
 ├─ cbor.rs
 └─ lib.rs

pub trait Serializer {
    fn encode<T: Serialize>(&self, value: &T) -> Result<Vec<u8>>;
    fn decode<T: DeserializeOwned>(&self, data: &[u8]) -> Result<T>;
}

plugin-example/
 ├─ src/lib.rs
 └─ manifest.toml

#[async_trait::async_trait]
pub trait Plugin: Send + Sync {
    fn metadata(&self) -> PluginMetadata;
    async fn execute(&self, ctx: PluginContext) -> Result<PluginOutput>;
}

#[async_trait::async_trait]
pub trait Sandbox {
    async fn run<F, T>(&self, f: F) -> Result<T>
    where
        F: Future<Output = Result<T>> + Send;
}

#[async_trait::async_trait]
pub trait Timeout {
    async fn with_timeout<F, T>(&self, dur: Duration, f: F) -> Result<T>
    where
        F: Future<Output = Result<T>> + Send;
}

#[async_trait::async_trait]
pub trait CircuitBreaker {
    async fn call<F, T>(&self, key: &str, f: F) -> Result<T>
    where
        F: Future<Output = Result<T>> + Send;
}

#[async_trait::async_trait]
pub trait Authenticator {
    async fn authenticate(&self, token: &str) -> Result<Identity>;
}

pub trait TlsProvider {
    fn client_config(&self) -> TlsConfig;
    fn server_config(&self) -> TlsConfig;
}

pub trait Telemetry {
    fn record_span(&self, name: &str);
    fn record_metric(&self, key: &str, value: f64);
}

api-server/
 ├─ router/
 ├─ handlers/
 ├─ middleware/
 └─ main.rs

async fn create_project(
    Json(dto): Json<ProjectDto>,
    State(app): State<AppState>,
) -> Result<Json<ProjectDto>> {
    let domain = dto.try_into()?;
    let out = app.service.execute(domain).await?;
    Ok(Json(out.into()))
}

wasm/
 ├─ bindings.rs
 └─ lib.rs

#[wasm_bindgen]
pub async fn run(input: JsValue) -> Result<JsValue, JsValue> {
    let dto: ProjectDto = serde_wasm_bindgen::from_value(input)?;
    let out = service.execute(dto.try_into()?).await?;
    Ok(serde_wasm_bindgen::to_value(&ProjectDto::from(out))?)
}

pub trait EventBus {
    async fn publish(&self, evt: Event) -> Result<()>;
    async fn subscribe(&self, topic: &str) -> Result<Stream<Event>>;
}

#[derive(thiserror::Error)]
pub enum AppError {
    #[error("validation error")]
    Validation,
    #[error("internal error")]
    Internal,
}