Rust client

use woven_client::{Client, ClientConfig, ClientTlsConfig};
use woven_protocol::AuthenticationScheme;

async fn connect(
    descriptor: &serde_json::Value,
    application_roots: Option<rustls::RootCertStore>,
) -> Result<(Client, u64, u64), Box<dyn std::error::Error>> {
    let endpoint = descriptor["endpoint"].as_str().ok_or("missing endpoint")?;
    let token = descriptor["token"].as_str().ok_or("missing token")?;
    let namespace_id = descriptor["namespaceId"]
        .as_str().ok_or("missing namespaceId")?.parse::<u64>()?;
    let session_id = descriptor["sessionId"]
        .as_str().ok_or("missing sessionId")?.parse::<u64>()?;
    let tls = match descriptor["caPem"].as_str() {
        Some(ca_pem) => ClientTlsConfig::from_ca_pem(ca_pem.as_bytes())?,
        None => ClientTlsConfig::with_root_certificates(
            application_roots.ok_or("no TLS roots supplied")?,
        )?,
    };
    let client = Client::connect_with_tls_and_auth(
        ClientConfig {
            url: format!("quic://{endpoint}"),
            token: token.to_owned(),
            ..ClientConfig::default()
        },
        tls,
        AuthenticationScheme::Bearer,
    )
    .await?;

    Ok((client, namespace_id, session_id))
}

use std::time::Duration;
use woven_client::ManagedAdmissionOutcome;
use woven_protocol::{AdmissionStatus, QueueState};

let (cancel_tx, cancel_rx) = tokio::sync::oneshot::channel::<()>();
// Move cancel_tx to the owner of your explicit stop control and send ().
let cancellation = async move {
    let _ = cancel_rx.await;
};

let (mut client, outcome) = client
    .admit_with_cancellation(
        namespace_id,
        session_id,
        "one-logical-attempt".to_owned(),
        Duration::from_secs(30),
        cancellation,
    )
    .await?;

match outcome {
    ManagedAdmissionOutcome::Admission(result)
        if result.status == AdmissionStatus::Admitted => {}
    ManagedAdmissionOutcome::Queue(update)
        if update.state == QueueState::Admitted => {}
    other => return Err(format!("admission outcome: {other:?}").into()),
}

// After managed admission returns Admitted; no space subscription is needed.
client.logger().info("Scene loaded").await?;
client.logger().warn("Optional asset unavailable").await?;
client.logger().error("Failed to save progress").await?;
client.log("Info-level alias").await?;

// Sending is not a database acknowledgement. Continue receiving control traffic
// to observe server rejections. Host stores a rolling 200-event debug history.

use std::time::Duration;
use woven_protocol::{ControlPayload, MessagePayload};

let space = descriptor["spaces"].as_array()
    .and_then(|spaces| spaces.first()).ok_or("missing space")?;
let space_id = space["spaceId"].as_str().ok_or("missing spaceId")?.parse::<u64>()?;
let space_epoch = space["epoch"].as_str().ok_or("missing epoch")?.parse::<u64>()?;
let has_channel_one = space["channelIds"].as_array()
    .is_some_and(|ids| ids.iter().any(|id| id.as_str() == Some("1")));
if !has_channel_one {
    return Err("channel 1 is not allowed for this space".into());
}

client
    .subscribe_space(namespace_id, session_id, space_id, space_epoch, 1)
    .await?;

let accepted = client.recv_timeout(Duration::from_secs(2)).await?
    .ok_or("subscription response timed out")?;
if !matches!(accepted.message,
    MessagePayload::Control(ControlPayload::SubscriptionAccepted(_))) {
    return Err("subscription was not accepted".into());
}

let entered = client.recv_timeout(Duration::from_secs(2)).await?
    .ok_or("entity assignment timed out")?;
if !matches!(entered.message,
    MessagePayload::Control(ControlPayload::EntityEntered(_))) {
    return Err("server did not assign an entity".into());
}
let entity_id = entered.entity_id.ok_or("missing assigned entity ID")?;

client
    .publish_event(
        namespace_id,
        session_id,
        space_id,
        space_epoch,
        1, // channel 1: ReliableOrdered / Ephemeral on the managed node
        entity_id,
        1, // sender sequence; increment for each event in this scope
        1, // application-defined payload type ID
        b"hello from Woven Host".to_vec(),
    )
    .await?;

client.close_gracefully(Duration::from_secs(2)).await?;