From e46bcbd55b7ab180617f714f571d2e2fd33fe20d Mon Sep 17 00:00:00 2001 From: herrfeder <14598229+herrfeder@users.noreply.github.com> Date: Thu, 7 May 2026 20:46:23 +0200 Subject: [PATCH 1/5] adding livekit integration files --- crates/matrix-sdk-rtc-livekit/Cargo.toml | 44 ++ crates/matrix-sdk-rtc-livekit/README.md | 42 + crates/matrix-sdk-rtc-livekit/build.rs | 12 + .../src/element_call.rs | 98 +++ crates/matrix-sdk-rtc-livekit/src/lib.rs | 734 ++++++++++++++++++ .../src/per_participant.rs | 600 ++++++++++++++ crates/matrix-sdk/src/widget/element_call.rs | 518 ++++++++++++ examples/rtc_livekit_join/Cargo.toml | 52 ++ examples/rtc_livekit_join/README.md | 82 ++ examples/rtc_livekit_join/src/main.rs | 455 +++++++++++ examples/rtc_livekit_join/src/videosource.rs | 470 +++++++++++ 11 files changed, 3107 insertions(+) create mode 100644 crates/matrix-sdk-rtc-livekit/Cargo.toml create mode 100644 crates/matrix-sdk-rtc-livekit/README.md create mode 100644 crates/matrix-sdk-rtc-livekit/build.rs create mode 100644 crates/matrix-sdk-rtc-livekit/src/element_call.rs create mode 100644 crates/matrix-sdk-rtc-livekit/src/lib.rs create mode 100644 crates/matrix-sdk-rtc-livekit/src/per_participant.rs create mode 100644 crates/matrix-sdk/src/widget/element_call.rs create mode 100644 examples/rtc_livekit_join/Cargo.toml create mode 100644 examples/rtc_livekit_join/README.md create mode 100644 examples/rtc_livekit_join/src/main.rs create mode 100644 examples/rtc_livekit_join/src/videosource.rs diff --git a/crates/matrix-sdk-rtc-livekit/Cargo.toml b/crates/matrix-sdk-rtc-livekit/Cargo.toml new file mode 100644 index 00000000000..32c41b99fec --- /dev/null +++ b/crates/matrix-sdk-rtc-livekit/Cargo.toml @@ -0,0 +1,44 @@ +[package] +name = "matrix-sdk-rtc-livekit" +description = "LiveKit SDK integration for matrix-rust-sdk." +version = "0.16.0" +edition = "2024" +repository = "https://github.com/matrix-org/matrix-rust-sdk" +license = "Apache-2.0" +rust-version.workspace = true +build = "build.rs" + +[package.metadata.docs.rs] +rustdoc-args = ["--generate-link-to-definition"] + +[features] +default = ["rustls-tls"] + +rustls-tls = ["matrix-sdk/rustls-tls", "livekit/rustls-tls-native-roots"] +native-tls = ["matrix-sdk/native-tls", "livekit/native-tls"] +js = ["matrix-sdk/js"] +experimental-widgets = ["matrix-sdk/experimental-widgets"] + +[dependencies] +async-trait.workspace = true +base64.workspace = true +livekit = { git = "https://github.com/onestacked/livekit-rust-sdks", branch = "EC-compat-changes" } +matrix-sdk = { workspace = true, features = ["e2e-encryption", "experimental-send-custom-to-device"] } +matrix-sdk-base.workspace = true +matrix-sdk-crypto.workspace = true +rand.workspace = true +ruma.workspace = true +serde = { workspace = true, features = ["derive"] } +serde_json.workspace = true +reqwest.workspace = true +futures-util.workspace = true +thiserror.workspace = true +tokio.workspace = true +tracing.workspace = true +url.workspace = true + +[dev-dependencies] +tokio.workspace = true + +[lints] +workspace = true diff --git a/crates/matrix-sdk-rtc-livekit/README.md b/crates/matrix-sdk-rtc-livekit/README.md new file mode 100644 index 00000000000..41fc053eb40 --- /dev/null +++ b/crates/matrix-sdk-rtc-livekit/README.md @@ -0,0 +1,42 @@ +# matrix-sdk-rtc-livekit + +LiveKit SDK integration for MatrixRTC room calls, including the connection traits and service URL helpers. + +## Toolchain setup (Linux) + +The LiveKit Rust SDK builds native WebRTC components. On Linux, the build is +most reliable with clang and libc++. + +Install libc++ and libc++abi (Ubuntu/Debian): + +```bash +sudo apt-get install -y libc++-dev libc++abi-dev +``` + +Build with clang + libc++: + +```bash +CC=clang CXX=clang++ CXXFLAGS="-stdlib=libc++" \ + cargo build -p matrix-sdk-rtc-livekit +``` + +If clang still picks GCC's headers, force the libc++ include path: + +```bash +CC=clang CXX=clang++ CXXFLAGS="-stdlib=libc++ -isystem /usr/include/c++/v1" \ + cargo build -p matrix-sdk-rtc-livekit +``` + +### Linker errors about `std::__1` symbols + +If you see linker errors that mention `std::__1` (libc++), it means some native +objects were built against libc++ but the final link step is using libstdc++. + +Try one of the following: + +- Ensure libc++ and libc++abi are installed (see above). +- Explicitly link libc++/libc++abi when building: + +```bash +RUSTFLAGS="-l c++ -l c++abi" cargo build -p matrix-sdk-rtc-livekit +``` diff --git a/crates/matrix-sdk-rtc-livekit/build.rs b/crates/matrix-sdk-rtc-livekit/build.rs new file mode 100644 index 00000000000..f2777c92c5f --- /dev/null +++ b/crates/matrix-sdk-rtc-livekit/build.rs @@ -0,0 +1,12 @@ +use std::env; + +fn main() { + let cxx = env::var("CXX").unwrap_or_else(|_| "c++".to_owned()); + let lowered = cxx.to_ascii_lowercase(); + if lowered.contains("g++") || lowered.contains("gcc") { + println!( + "cargo:warning=LiveKit's WebRTC build is more reliable with clang; \ + try `CC=clang CXX=clang++` if you hit C++ compilation errors." + ); + } +} diff --git a/crates/matrix-sdk-rtc-livekit/src/element_call.rs b/crates/matrix-sdk-rtc-livekit/src/element_call.rs new file mode 100644 index 00000000000..dd486cdec48 --- /dev/null +++ b/crates/matrix-sdk-rtc-livekit/src/element_call.rs @@ -0,0 +1,98 @@ +use matrix_sdk::{ + Room as MatrixRoom, + ruma::events::call::member::CallMemberStateKey, + widget::{ + ClientProperties, ElementCallWidget, ElementCallWidgetOptions, EncryptionSystem, Intent, + publish_call_membership_via_widget, send_hangup_via_widget, start_element_call_widget, + }, +}; + +use crate::{LiveKitError, LiveKitResult}; + +/// Resolve the Element Call encryption mode from the room state. +pub async fn element_call_encryption_for_room( + room: &MatrixRoom, +) -> LiveKitResult { + let encryption_state = room.latest_encryption_state().await.map_err(LiveKitError::widget)?; + + if encryption_state.is_encrypted() { + return Ok(EncryptionSystem::PerParticipantKeys); + } + + Ok(EncryptionSystem::Unencrypted) +} + +/// Start Element Call with sensible defaults for a MatrixRTC join flow. +pub async fn start_element_call_widget_for_room( + room: MatrixRoom, + element_call_url: impl Into, +) -> LiveKitResult { + let options = ElementCallWidgetOptions { + widget_id: "element-call".to_owned(), + parent_url: None, + encryption: element_call_encryption_for_room(&room).await?, + intent: Intent::JoinExisting, + client_properties: ClientProperties::new("matrix-sdk-rtc-livekit-join", None, None), + }; + + LiveKitElementCallWidget::start(room, element_call_url, options).await +} + +/// Running Element Call widget integration for a LiveKit room session. +#[derive(Debug)] +pub struct LiveKitElementCallWidget { + room: MatrixRoom, + widget: ElementCallWidget, + shutdown_membership_state_key: CallMemberStateKey, +} + +impl LiveKitElementCallWidget { + /// Start the Element Call widget and initialize metadata needed for hangup signaling. + pub async fn start( + room: MatrixRoom, + element_call_url: impl Into, + options: ElementCallWidgetOptions, + ) -> LiveKitResult { + let widget = start_element_call_widget(room.clone(), element_call_url.into(), options) + .await + .map_err(LiveKitError::widget)?; + + let own_user_id = room + .client() + .user_id() + .ok_or_else(|| { + LiveKitError::widget(std::io::Error::other( + "missing user id for widget shutdown event", + )) + })? + .to_owned(); + let own_device_id = room + .client() + .device_id() + .ok_or_else(|| { + LiveKitError::widget(std::io::Error::other( + "missing device id for widget shutdown event", + )) + })? + .to_owned(); + + let shutdown_membership_state_key = + CallMemberStateKey::new(own_user_id, Some(own_device_id.to_string()), true); + + Ok(Self { room, widget, shutdown_membership_state_key }) + } + + /// Publish an active-call membership update via the widget API. + pub async fn publish_membership(&self, service_url: &str) -> LiveKitResult<()> { + publish_call_membership_via_widget(self.room.clone(), &self.widget, service_url) + .await + .map_err(LiveKitError::widget) + } + + /// Send a shutdown membership update via the widget API. + pub async fn send_hangup(&self) -> LiveKitResult<()> { + send_hangup_via_widget(&self.widget, Some(&self.shutdown_membership_state_key)) + .await + .map_err(LiveKitError::widget) + } +} diff --git a/crates/matrix-sdk-rtc-livekit/src/lib.rs b/crates/matrix-sdk-rtc-livekit/src/lib.rs new file mode 100644 index 00000000000..c18a4a327bd --- /dev/null +++ b/crates/matrix-sdk-rtc-livekit/src/lib.rs @@ -0,0 +1,734 @@ +//! LiveKit SDK integration for MatrixRTC room calls. + +use std::{error::Error, future::Future, sync::Arc}; + +use async_trait::async_trait; +use matrix_sdk::{Client, HttpError, Room as MatrixRoom}; +use reqwest::Client as HttpClient; +use ruma::{ + OwnedRoomId, + api::client::{account::request_openid_token, discovery::discover_homeserver::RtcFocusInfo}, +}; +use serde_json::Value as JsonValue; +use thiserror::Error; + +#[cfg(feature = "experimental-widgets")] +pub mod element_call; +pub mod per_participant; + +pub use livekit; +use livekit::RoomEvent; +pub use livekit::e2ee; +use livekit::id::ParticipantIdentity; +pub use livekit::{ConnectionState, Room, RoomOptions}; +use tokio::sync::Mutex; +use tracing::info; +use url::Url; + +/// Errors returned by the LiveKit integration layer. +#[derive(Debug, Error)] +pub enum LiveKitError { + /// The homeserver did not advertise a LiveKit focus. + #[error("missing livekit focus in homeserver discovery response")] + MissingLiveKitFocus, + + /// The homeserver discovery request failed. + #[error(transparent)] + Http(#[from] HttpError), + + /// The LiveKit connector failed. + #[error("livekit connector error: {0}")] + Connector(Box), + + /// Element Call widget integration failed. + #[cfg(feature = "experimental-widgets")] + #[error("element call widget error: {0}")] + Widget(Box), +} + +impl LiveKitError { + /// Wrap a connector-specific error. + pub fn connector(error: E) -> Self + where + E: Error + Send + Sync + 'static, + { + Self::Connector(Box::new(error)) + } +} + +#[cfg(feature = "experimental-widgets")] +impl LiveKitError { + /// Wrap a widget-specific error. + pub fn widget(error: E) -> Self + where + E: Error + Send + Sync + 'static, + { + Self::Widget(Box::new(error)) + } +} + +/// Result type for LiveKit operations. +pub type LiveKitResult = Result; + +/// A LiveKit connection instance created by the connector. +#[async_trait] +pub trait LiveKitConnection: Send + Sync { + /// Disconnect and tear down the LiveKit room connection. + async fn disconnect(self) -> LiveKitResult<()>; +} + +/// A connector capable of creating LiveKit room connections. +#[async_trait] +pub trait LiveKitConnector: Send + Sync { + /// The type for LiveKit room connections. + type Connection: LiveKitConnection; + + /// Connect to a LiveKit room for the given room id. + async fn connect( + &self, + service_url: &str, + room: &MatrixRoom, + ) -> LiveKitResult; +} + +/// Select the LiveKit service URL from the advertised RTC foci. +pub fn select_livekit_service_url(rtc_foci: &[RtcFocusInfo]) -> Option { + rtc_foci.iter().find_map(|focus| match focus { + RtcFocusInfo::LiveKit(info) => Some(info.service_url.clone()), + _ => None, + }) +} + +/// Convenience helper to fetch the LiveKit service URL for a client. +pub async fn livekit_service_url(client: &Client) -> LiveKitResult { + let rtc_foci = client.rtc_foci().await?; + select_livekit_service_url(&rtc_foci).ok_or(LiveKitError::MissingLiveKitFocus) +} + +/// Drive a LiveKit connection based on active room call memberships. +#[derive(Debug)] +pub struct LiveKitRoomDriver { + room: MatrixRoom, + connector: C, + connection: Option, +} + +impl LiveKitRoomDriver +where + C: LiveKitConnector, +{ + /// Create a new driver for a room. + pub fn new(room: MatrixRoom, connector: C) -> Self { + Self { room, connector, connection: None } + } + + /// Run the driver until the room info stream ends. + pub async fn run(mut self) -> LiveKitResult<()> { + let service_url = livekit_service_url(&self.room.client()).await?; + let mut info_stream = self.room.subscribe_info(); + + self.apply_connection_update(&service_url, &self.room.clone_info()).await?; + + while let Some(room_info) = info_stream.next().await { + self.apply_connection_update(&service_url, &room_info).await?; + } + + if let Some(connection) = self.connection.take() { + connection.disconnect().await?; + } + + Ok(()) + } + + async fn apply_connection_update( + &mut self, + service_url: &str, + room_info: &matrix_sdk::RoomInfo, + ) -> LiveKitResult<()> { + match plan_connection_update(room_info, &mut self.connection) { + ConnectionUpdatePlan::Join => { + info!(room_id = ?self.room.room_id(), "joining LiveKit room for active call"); + let connection = self.connector.connect(service_url, &self.room).await?; + self.connection = Some(connection); + } + ConnectionUpdatePlan::Leave(connection) => { + info!(room_id = ?self.room.room_id(), "leaving LiveKit room because the call ended"); + connection.disconnect().await?; + } + ConnectionUpdatePlan::Unchanged => {} + } + + Ok(()) + } +} + +/// A token provider for joining LiveKit rooms. +#[async_trait] +pub trait LiveKitTokenProvider: Send + Sync { + /// Provide a LiveKit access token for the given Matrix room. + async fn token(&self, room: &MatrixRoom) -> LiveKitResult; +} + +/// Provides LiveKit room options. +pub trait LiveKitRoomOptionsProvider: Send + Sync { + /// Create the LiveKit room options used when connecting to LiveKit. + fn room_options(&self) -> RoomOptions; +} + +impl LiveKitRoomOptionsProvider for F +where + F: Fn() -> RoomOptions + Send + Sync, +{ + fn room_options(&self) -> RoomOptions { + (self)() + } +} + +/// A token provider that always returns a fixed token. +#[derive(Debug, Clone)] +pub struct EnvLiveKitTokenProvider { + token: String, +} + +impl EnvLiveKitTokenProvider { + /// Create a provider from a static token value. + pub fn new(token: impl Into) -> Self { + Self { token: token.into() } + } +} + +#[async_trait] +impl LiveKitTokenProvider for EnvLiveKitTokenProvider { + async fn token(&self, _room: &MatrixRoom) -> LiveKitResult { + Ok(self.token.clone()) + } +} + +/// A room options provider that uses [`RoomOptions::default`]. +#[derive(Debug, Clone, Copy, Default)] +pub struct DefaultRoomOptionsProvider; + +impl LiveKitRoomOptionsProvider for DefaultRoomOptionsProvider { + fn room_options(&self) -> RoomOptions { + RoomOptions::default() + } +} + +/// Connection details used by the LiveKit SDK connector. +#[derive(Debug, Clone)] +pub struct LiveKitConnectionDetails { + /// LiveKit service URL. + pub service_url: String, + /// LiveKit JWT access token. + pub token: String, +} + +impl LiveKitConnectionDetails { + /// Return the service URL with `access_token` appended if missing. + pub fn authenticated_service_url(&self) -> LiveKitResult { + ensure_access_token_query(&self.service_url, &self.token) + } +} + +#[derive(Debug, thiserror::Error)] +enum LiveKitDetailsError { + #[error("missing LiveKit token")] + MissingToken, + #[error("missing user id for OpenID token request")] + MissingUserId, + #[error("missing device id for /sfu/get request")] + MissingDeviceId, + #[error("missing LiveKit service url in /sfu/get response")] + MissingSfuServiceUrl, + #[error("missing LiveKit token in /sfu/get response")] + MissingSfuToken, + #[error(transparent)] + UrlParse(#[from] url::ParseError), +} + +/// Resolve LiveKit connection details either from `/sfu/get` or static env values. +pub async fn resolve_connection_details( + client: &Client, + room: &MatrixRoom, + sfu_get_url: Option<&str>, + service_url_override: Option<&str>, + static_token: Option<&str>, +) -> LiveKitResult { + if let Some(sfu_url) = sfu_get_url { + let openid_token = request_openid_token(client).await?; + let device_id = client + .device_id() + .ok_or_else(|| LiveKitError::connector(LiveKitDetailsError::MissingDeviceId))? + .to_string(); + let (service_url, token) = + fetch_sfu_token(sfu_url, room.room_id().to_owned(), device_id, &openid_token).await?; + return Ok(LiveKitConnectionDetails { service_url, token }); + } + + let token = static_token + .ok_or_else(|| LiveKitError::connector(LiveKitDetailsError::MissingToken))? + .to_owned(); + let service_url = match service_url_override { + Some(url) => url.to_owned(), + None => livekit_service_url(client).await?, + }; + + Ok(LiveKitConnectionDetails { service_url, token }) +} + +/// Prepared SDK connector configuration for running the LiveKit room driver. +#[derive(Debug)] +pub struct PreparedLiveKitSdkConnector { + /// LiveKit service URL (including access token query parameter when needed). + pub service_url: String, + /// SDK connector configured with token and room options providers. + pub connector: LiveKitSdkConnector, + /// Length of the resolved token, useful for structured logging. + pub token_len: usize, +} + +/// Resolve connection details and build a [`LiveKitSdkConnector`] ready for driver execution. +pub async fn prepare_livekit_sdk_connector( + client: &Client, + room: &MatrixRoom, + sfu_get_url: Option<&str>, + service_url_override: Option<&str>, + static_token: Option<&str>, + room_options_provider: O, +) -> LiveKitResult> +where + O: LiveKitRoomOptionsProvider, +{ + let connection_details = + resolve_connection_details(client, room, sfu_get_url, service_url_override, static_token) + .await?; + let service_url = connection_details.authenticated_service_url()?; + let token = connection_details.token; + let token_len = token.len(); + let token_provider = EnvLiveKitTokenProvider::new(token); + let connector = LiveKitSdkConnector::new(token_provider, room_options_provider); + + Ok(PreparedLiveKitSdkConnector { service_url, connector, token_len }) +} + +async fn request_openid_token( + client: &Client, +) -> LiveKitResult { + let user_id = client + .user_id() + .ok_or_else(|| LiveKitError::connector(LiveKitDetailsError::MissingUserId))?; + let request = request_openid_token::v3::Request::new(user_id.to_owned()); + let response = client.send(request).await?; + Ok(response) +} + +#[derive(serde::Serialize)] +struct SfuGetRequest { + room: String, + openid_token: OpenIdToken, + device_id: String, +} + +#[derive(serde::Serialize)] +struct OpenIdToken { + access_token: String, + expires_in: u64, + matrix_server_name: String, + token_type: String, +} + +async fn fetch_sfu_token( + url: &str, + room_id: OwnedRoomId, + device_id: String, + openid_token: &request_openid_token::v3::Response, +) -> LiveKitResult<(String, String)> { + let request_body = SfuGetRequest { + room: room_id.to_string(), + openid_token: OpenIdToken { + access_token: openid_token.access_token.clone(), + expires_in: openid_token.expires_in.as_secs(), + matrix_server_name: openid_token.matrix_server_name.to_string(), + token_type: openid_token.token_type.to_string(), + }, + device_id, + }; + let client = HttpClient::new(); + let request = client.post(url).json(&request_body); + + let response = request + .send() + .await + .map_err(LiveKitError::connector)? + .error_for_status() + .map_err(LiveKitError::connector)?; + let payload: JsonValue = response.json().await.map_err(LiveKitError::connector)?; + + let service_url = extract_string( + &payload, + &["service_url", "livekit_service_url", "livekit_url", "sfu_base_url", "sfu_url", "url"], + ) + .ok_or_else(|| LiveKitError::connector(LiveKitDetailsError::MissingSfuServiceUrl))?; + let token = extract_string(&payload, &["token", "jwt", "access_token"]) + .ok_or_else(|| LiveKitError::connector(LiveKitDetailsError::MissingSfuToken))?; + + Ok((service_url, token)) +} + +fn extract_string(payload: &JsonValue, keys: &[&str]) -> Option { + keys.iter().find_map(|key| { + payload.get(*key).and_then(|value| value.as_str()).map(|value| value.to_owned()) + }) +} + +fn ensure_access_token_query(service_url: &str, token: &str) -> LiveKitResult { + let mut url = Url::parse(service_url) + .map_err(|e| LiveKitError::connector(LiveKitDetailsError::UrlParse(e)))?; + let has_access_token = url.query_pairs().any(|(key, _)| key == "access_token"); + if !has_access_token { + url.query_pairs_mut().append_pair("access_token", token); + } + Ok(url.into()) +} + +/// A LiveKit connection backed by the LiveKit Rust SDK. +#[derive(Debug)] +pub struct LiveKitSdkConnection { + room: Room, + events: Mutex>>, +} + +impl LiveKitSdkConnection { + /// Access the underlying LiveKit room handle. + pub fn room(&self) -> &Room { + &self.room + } + + /// Consume and return the LiveKit room event stream. + /// + /// Returns `None` if the stream has already been taken. + pub async fn take_events(&self) -> Option> { + self.events.lock().await.take() + } + + /// Consume this connection and return the underlying LiveKit room. + pub fn into_room(self) -> Room { + self.room + } +} + +#[async_trait] +impl LiveKitConnection for LiveKitSdkConnection { + async fn disconnect(self) -> LiveKitResult<()> { + drop(self); + Ok(()) + } +} + +/// Connector implementation that joins rooms using the LiveKit Rust SDK. +#[derive(Debug)] +pub struct LiveKitSdkConnector { + token_provider: T, + room_options: O, +} + +impl LiveKitSdkConnector { + /// Create a new connector using the provided token provider and room options. + pub fn new(token_provider: T, room_options: O) -> Self { + Self { token_provider, room_options } + } + + /// Access the configured token provider. + pub fn token_provider(&self) -> &T { + &self.token_provider + } + + /// Access the configured room options provider. + pub fn room_options_provider(&self) -> &O { + &self.room_options + } +} + +/// Stream of events received from a joined LiveKit room. +pub type LiveKitRoomEvents = tokio::sync::mpsc::UnboundedReceiver; + +/// Update event emitted by [`update_connection`]. +#[derive(Debug)] +pub enum LiveKitConnectionUpdate { + Joined { room: Arc, events: Option }, + Left, + Unchanged, +} + +/// Handle a connection update by delegating joined/left transitions. +pub async fn handle_joined_left_connection_update( + state: S, + update: LiveKitConnectionUpdate, + on_joined: &J, + on_left: &L, +) -> LiveKitResult +where + J: Fn(S, Arc, Option) -> JFut, + L: Fn(S) -> LFut, + JFut: Future>, + LFut: Future>, +{ + match update { + LiveKitConnectionUpdate::Joined { room, events } => on_joined(state, room, events).await, + LiveKitConnectionUpdate::Left => on_left(state).await, + LiveKitConnectionUpdate::Unchanged => Ok(state), + } +} + +/// Handle a connection update and return the next driver state. +pub async fn handle_connection_update( + state: S, + update: LiveKitConnectionUpdate, + handler: &F, +) -> LiveKitResult +where + F: Fn(S, LiveKitConnectionUpdate) -> Fut, + Fut: Future>, +{ + handler(state, update).await +} + +enum ConnectionUpdatePlan { + Join, + Leave(C), + Unchanged, +} + +fn plan_connection_update( + room_info: &matrix_sdk::RoomInfo, + connection: &mut Option, +) -> ConnectionUpdatePlan { + if room_info.has_active_room_call() { + if connection.is_none() { + ConnectionUpdatePlan::Join + } else { + ConnectionUpdatePlan::Unchanged + } + } else if let Some(connection) = connection.take() { + ConnectionUpdatePlan::Leave(connection) + } else { + ConnectionUpdatePlan::Unchanged + } +} + +/// Update an existing LiveKit connection based on room call memberships. +pub async fn update_connection( + room: &matrix_sdk::Room, + connector: &LiveKitSdkConnector, + service_url: &str, + room_info: &matrix_sdk::RoomInfo, + connection: &mut Option>, +) -> LiveKitResult +where + T: LiveKitTokenProvider, + O: LiveKitRoomOptionsProvider, +{ + match plan_connection_update(room_info, connection) { + ConnectionUpdatePlan::Join => { + info!(room_id = ?room.room_id(), "joining LiveKit room for active call"); + let new_connection = connector.connect(service_url, room).await?; + let livekit_events = new_connection.take_events().await; + let room_handle = Arc::new(new_connection.into_room()); + *connection = Some(Arc::clone(&room_handle)); + Ok(LiveKitConnectionUpdate::Joined { room: room_handle, events: livekit_events }) + } + ConnectionUpdatePlan::Leave(_) => { + info!(room_id = ?room.room_id(), "leaving LiveKit room because the call ended"); + Ok(LiveKitConnectionUpdate::Left) + } + ConnectionUpdatePlan::Unchanged => Ok(LiveKitConnectionUpdate::Unchanged), + } +} + +/// Run the LiveKit room driver while delegating connection updates to a custom handler. +pub async fn run_livekit_driver_with_handler( + room: matrix_sdk::Room, + connector: &LiveKitSdkConnector, + service_url: &str, + mut state: S, + handler: F, +) -> LiveKitResult +where + T: LiveKitTokenProvider, + O: LiveKitRoomOptionsProvider, + F: Fn(S, LiveKitConnectionUpdate) -> Fut, + Fut: Future>, +{ + let mut connection: Option> = None; + let mut info_stream = room.subscribe_info(); + + let initial_update = + update_connection(&room, connector, service_url, &room.clone_info(), &mut connection) + .await?; + state = handle_connection_update(state, initial_update, &handler).await?; + + while let Some(room_info) = info_stream.next().await { + let update = + update_connection(&room, connector, service_url, &room_info, &mut connection).await?; + state = handle_connection_update(state, update, &handler).await?; + } + + let _ = connection.take(); + + Ok(state) +} + +/// Run the LiveKit room driver and delegate joined/left transitions to dedicated handlers. +pub async fn run_livekit_driver_joined_left( + room: matrix_sdk::Room, + connector: &LiveKitSdkConnector, + service_url: &str, + state: S, + on_joined: J, + on_left: L, +) -> LiveKitResult +where + T: LiveKitTokenProvider, + O: LiveKitRoomOptionsProvider, + J: Fn(S, Arc, Option) -> JFut, + L: Fn(S) -> LFut, + JFut: Future>, + LFut: Future>, +{ + run_livekit_driver_with_handler(room, connector, service_url, state, |state, update| async { + handle_joined_left_connection_update(state, update, &on_joined, &on_left).await + }) + .await +} + +#[async_trait] +impl LiveKitConnector for LiveKitSdkConnector +where + T: LiveKitTokenProvider, + O: LiveKitRoomOptionsProvider, +{ + type Connection = LiveKitSdkConnection; + + async fn connect( + &self, + service_url: &str, + room: &MatrixRoom, + ) -> LiveKitResult { + let token = self.token_provider.token(room).await?; + let mut room_options = self.room_options_provider().room_options(); + #[allow(deprecated)] + if room_options.encryption.is_none() { + room_options.encryption = room_options.e2ee.clone(); + } + + if let Some(encryption) = room_options.encryption.as_ref() { + let key_provider = &encryption.key_provider; + let key_index = key_provider.get_latest_key_index(); + let maybe_local_key = room + .client() + .user_id() + .zip(room.client().device_id()) + .map(|(user_id, device_id)| ParticipantIdentity(format!("{user_id}:{device_id}"))) + .and_then(|identity| key_provider.get_key(&identity, key_index)); + info!( + room_id = ?room.room_id(), + key_index, + key_provider_key = ?maybe_local_key, + "resolved LiveKit encryption key_provider key before connect" + ); + } + info!( + room_id = ?room.room_id(), + service_url, + room_options = ?room_options, + "connecting to LiveKit room with resolved room options" + ); + let (livekit_room, events) = Room::connect(service_url, &token, room_options) + .await + .map_err(LiveKitError::connector)?; + Ok(LiveKitSdkConnection { room: livekit_room, events: Mutex::new(Some(events)) }) + } +} + +#[cfg(test)] +mod tests { + use super::{ + LiveKitConnectionDetails, LiveKitConnectionUpdate, LiveKitError, handle_connection_update, + select_livekit_service_url, + }; + use ruma::api::client::discovery::discover_homeserver::RtcFocusInfo; + + #[test] + fn select_livekit_service_url_prefers_first_livekit_focus() { + let rtc_foci = vec![ + RtcFocusInfo::livekit("https://livekit-1.example.org".to_owned()), + RtcFocusInfo::livekit("https://livekit-2.example.org".to_owned()), + ]; + + let service_url = select_livekit_service_url(&rtc_foci); + + assert_eq!(service_url.as_deref(), Some("https://livekit-1.example.org")); + } + + #[test] + fn select_livekit_service_url_returns_none_for_empty_list() { + assert_eq!(select_livekit_service_url(&[]), None); + } + + #[test] + fn authenticated_service_url_adds_access_token() { + let details = LiveKitConnectionDetails { + service_url: "https://livekit.example.org/room?id=123".to_owned(), + token: "secret-token".to_owned(), + }; + + let authenticated_url = details.authenticated_service_url().unwrap(); + + assert_eq!( + authenticated_url, + "https://livekit.example.org/room?id=123&access_token=secret-token" + ); + } + + #[test] + fn authenticated_service_url_preserves_existing_access_token() { + let details = LiveKitConnectionDetails { + service_url: "https://livekit.example.org/room?access_token=existing".to_owned(), + token: "ignored-token".to_owned(), + }; + + let authenticated_url = details.authenticated_service_url().unwrap(); + + assert_eq!(authenticated_url, "https://livekit.example.org/room?access_token=existing"); + } + + #[test] + fn authenticated_service_url_returns_error_for_invalid_url() { + let details = LiveKitConnectionDetails { + service_url: "not a valid url".to_owned(), + token: "token".to_owned(), + }; + + let error = details.authenticated_service_url().unwrap_err(); + + assert!(matches!(error, LiveKitError::Connector(_))); + } + + #[tokio::test] + async fn handle_connection_update_propagates_handler_state_change() { + let result = handle_connection_update( + String::new(), + LiveKitConnectionUpdate::Left, + &|mut state, update| async move { + if matches!(update, LiveKitConnectionUpdate::Left) { + state.push_str("left"); + } + Ok(state) + }, + ) + .await + .unwrap(); + + assert_eq!(result, "left"); + } +} diff --git a/crates/matrix-sdk-rtc-livekit/src/per_participant.rs b/crates/matrix-sdk-rtc-livekit/src/per_participant.rs new file mode 100644 index 00000000000..487e6aac7a3 --- /dev/null +++ b/crates/matrix-sdk-rtc-livekit/src/per_participant.rs @@ -0,0 +1,600 @@ +//! Per-participant E2EE helpers for LiveKit + MatrixRTC. + +use std::{sync::Arc, time::Duration}; + +use base64::{ + Engine as _, + engine::general_purpose::{STANDARD, STANDARD_NO_PAD, URL_SAFE, URL_SAFE_NO_PAD}, +}; +use livekit::{ + RoomEvent, + e2ee::{ + E2eeOptions, EncryptionType, + key_provider::{KeyDerivationFunction, KeyProvider, KeyProviderOptions}, + }, + id::ParticipantIdentity, +}; +use matrix_sdk::{Client, Room, RoomMemberships, event_handler::EventHandlerDropGuard}; +use matrix_sdk_base::crypto::CollectStrategy; +use rand::{RngCore, rngs::OsRng}; +use ruma::serde::Raw; +use ruma::{OwnedRoomId, events::AnyToDeviceEvent}; +use serde::Deserialize; +use thiserror::Error; +use tracing::{debug, info, warn}; + +use crate::LiveKitRoomOptionsProvider; + +/// Runtime context for per-participant LiveKit E2EE. +#[derive(Clone)] +pub struct PerParticipantE2eeContext { + pub key_provider: Arc, + pub key_index: i32, + pub local_key: Vec, +} + +/// LiveKit room options provider with optional per-participant E2EE. +#[derive(Clone)] +pub struct E2eeRoomOptionsProvider { + pub e2ee: Option, +} + +impl LiveKitRoomOptionsProvider for E2eeRoomOptionsProvider { + fn room_options(&self) -> livekit::RoomOptions { + let mut options = livekit::RoomOptions::default(); + if let Some(context) = &self.e2ee { + options.encryption = Some(E2eeOptions { + encryption_type: EncryptionType::Gcm, + key_provider: KeyProvider::clone(context.key_provider.as_ref()), + }); + } + options + } +} + +/// Precomputed per-participant E2EE providers used by the example runtime. +pub struct PerParticipantE2eeProviders { + pub room_options_provider: E2eeRoomOptionsProvider, + pub to_device_key_provider: Arc, +} + +/// Build the to-device key provider and room options provider from an optional E2EE context. +pub fn build_per_participant_providers( + room: &Room, + e2ee: Option, +) -> PerParticipantE2eeProviders { + let to_device_key_provider = if let Some(context) = e2ee.as_ref() { + Arc::clone(&context.key_provider) + } else { + warn!( + room_id = %room.room_id(), + "per-participant E2EE context unavailable; registering to-device handler with fallback key provider" + ); + let mut fallback_options = KeyProviderOptions::default(); + fallback_options.ratchet_window_size = 10; + fallback_options.key_ring_size = 256; + fallback_options.key_derivation_function = KeyDerivationFunction::HKDF; + Arc::new(KeyProvider::new(fallback_options)) + }; + + let room_options_provider = E2eeRoomOptionsProvider { e2ee }; + + PerParticipantE2eeProviders { room_options_provider, to_device_key_provider } +} + +/// Seed the local participant key into the key provider when user/device IDs are available. +pub fn seed_local_participant_key(client: &Client, e2ee: Option<&PerParticipantE2eeContext>) { + if let Some(context) = e2ee + && let (Some(user_id), Some(device_id)) = (client.user_id(), client.device_id()) + { + let identity = ParticipantIdentity(format!("{user_id}:{device_id}")); + let key_set = + context.key_provider.set_key(&identity, context.key_index, context.local_key.clone()); + info!( + %identity, + key_index = context.key_index, + key_set, + "seeded local per-participant E2EE key_provider key before LiveKit connect" + ); + } +} + +/// Runtime wiring needed by callers after preparing per-participant E2EE. +pub struct PreparedPerParticipantE2ee { + pub context: Option, + pub room_options_provider: E2eeRoomOptionsProvider, + pub to_device_guard: EventHandlerDropGuard, +} + +/// Periodically resend local per-participant keys. +pub fn spawn_periodic_e2ee_key_resend( + room: Room, + context: PerParticipantE2eeContext, + interval_secs: u64, +) { + if interval_secs == 0 { + return; + } + + tokio::spawn(async move { + let mut interval = tokio::time::interval(Duration::from_secs(interval_secs)); + loop { + interval.tick().await; + info!( + interval_secs, + key_index = context.key_index, + "periodic per-participant E2EE key resend" + ); + if let Err(err) = + send_per_participant_keys(&room, context.key_index, &context.local_key, None).await + { + info!(?err, "failed to resend per-participant E2EE keys"); + } + } + }); +} + +/// Build, seed, and wire all per-participant E2EE runtime helpers for a room. +pub async fn prepare_per_participant_e2ee( + room: &Room, + periodic_resend_secs: u64, +) -> Result { + let context = + build_per_participant_e2ee(room).await?; + seed_local_participant_key(&room.client(), context.as_ref()); + + let providers = build_per_participant_providers(room, context.clone()); + let to_device_guard = register_e2ee_to_device_handler( + &room.client(), + room.room_id().to_owned(), + providers.to_device_key_provider, + ); + + if let Some(context) = context.as_ref() { + spawn_periodic_e2ee_key_resend(room.clone(), context.clone(), periodic_resend_secs); + } + + Ok(PreparedPerParticipantE2ee { + context, + room_options_provider: providers.room_options_provider, + to_device_guard, + }) +} + +#[derive(Debug, Error)] +pub enum PerParticipantE2eeError { + #[error("missing device id for per-participant E2EE")] + MissingDeviceId, + #[error("missing user id for per-participant E2EE")] + MissingUserId, + #[error(transparent)] + Matrix(#[from] matrix_sdk::Error), + #[error(transparent)] + Serde(#[from] serde_json::Error), +} + +/// Build the initial per-participant E2EE context for a Matrix room. +pub async fn build_per_participant_e2ee( + room: &Room, +) -> Result, PerParticipantE2eeError> { + let mut key_provider_options = KeyProviderOptions::default(); + key_provider_options.ratchet_window_size = 10; + key_provider_options.key_ring_size = 256; + key_provider_options.key_derivation_function = KeyDerivationFunction::HKDF; + + let key_provider = Arc::new(KeyProvider::new(key_provider_options)); + let local_key = derive_per_participant_key(); + send_per_participant_keys(room, 0, &local_key, None).await?; + + Ok(Some(PerParticipantE2eeContext { key_provider, key_index: 0, local_key })) +} + +/// Generate local key material for per-participant media E2EE. +pub fn derive_per_participant_key() -> Vec { + let mut key = [0u8; 16]; + OsRng.fill_bytes(&mut key); + key.to_vec() +} + +/// Send `io.element.call.encryption_keys` to room members' devices. +pub async fn send_per_participant_keys( + room: &Room, + key_index: i32, + key: &[u8], + target_device_id: Option<&str>, +) -> Result<(), PerParticipantE2eeError> { + if key.is_empty() { + return Ok(()); + } + + let key = if key.len() >= 16 { &key[..16] } else { key }; + let client = room.client(); + let own_device_id = + client.device_id().ok_or(PerParticipantE2eeError::MissingDeviceId)?.to_owned(); + let own_user_id = client.user_id().map(|id| id.to_owned()); + + let members = room.members(RoomMemberships::JOIN).await?; + let mut recipients = Vec::new(); + for member in members { + let devices = client.encryption().get_user_devices(member.user_id()).await?; + for device in devices.devices() { + if let Some(own_user_id) = own_user_id.as_ref() + && device.user_id() == own_user_id + && device.device_id() == &own_device_id + { + continue; + } + if target_device_id.is_none_or(|target| device.device_id().as_str() == target) { + recipients.push(device); + } + } + } + + if recipients.is_empty() { + return Ok(()); + } + + let key_b64 = URL_SAFE_NO_PAD.encode(key); + let sent_ts = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap_or_default() + .as_millis() as u64; + + let own_user_id = client.user_id().ok_or(PerParticipantE2eeError::MissingUserId)?; + let claimed = own_device_id.as_str(); + let member_id = format!("{own_user_id}:{claimed}"); + + let content_raw = Raw::new(&serde_json::json!({ + "keys": { "index": key_index, "key": key_b64 }, + "device_id": claimed, + "member": { "claimed_device_id": claimed, "id": member_id }, + "room_id": room.room_id().to_string(), + "session": { + "application": "m.call", + "call_id": "", + "scope": "m.room" + }, + "sent_ts": sent_ts, + }))? + .cast_unchecked(); + + let _ = client + .encryption() + .encrypt_and_send_raw_to_device( + recipients.iter().collect(), + "io.element.call.encryption_keys", + content_raw, + CollectStrategy::AllDevices, + ) + .await?; + + Ok(()) +} + +/// Apply per-participant E2EE setup immediately after joining a LiveKit room. +pub async fn handle_per_participant_joined( + room: &Room, + room_handle: &Arc, + events: Option, + context: Option<&PerParticipantE2eeContext>, + key_grace_period_var: &str, + key_grace_period_default_ms: u64, +) { + let Some(context) = context else { + return; + }; + + let identity = room_handle.local_participant().identity(); + let key_set = + context.key_provider.set_key(&identity, context.key_index, context.local_key.clone()); + room_handle.e2ee_manager().set_enabled(true); + info!( + %identity, + key_index = context.key_index, + key_set, + "enabled per-participant E2EE for local participant" + ); + + if let Err(err) = + send_per_participant_keys(room, context.key_index, &context.local_key, None).await + { + info!(?err, "failed to send per-participant E2EE keys immediately after room connect"); + } + + let key_grace_period = per_participant_key_grace_period_from_env( + key_grace_period_var, + key_grace_period_default_ms, + ); + if !key_grace_period.is_zero() { + info!( + key_grace_period_ms = key_grace_period.as_millis(), + "waiting for per-participant E2EE key grace period before publishing media" + ); + tokio::time::sleep(key_grace_period).await; + } + + if let Some(events) = events { + spawn_livekit_e2ee_event_resend(room.clone(), events, context.clone()); + } +} + +/// Register a to-device handler that applies received per-participant keys. +pub fn register_e2ee_to_device_handler( + client: &Client, + room_id: OwnedRoomId, + key_provider: Arc, +) -> EventHandlerDropGuard { + let handle = client.add_event_handler(move |raw: Raw| { + let key_provider = Arc::clone(&key_provider); + let room_id = room_id.clone(); + async move { + let observed_event_type = raw + .get_field::("type") + .ok() + .flatten() + .unwrap_or_else(|| "".to_owned()); + + let event_map = match raw.deserialize_as::>() + { + Ok(event_map) => event_map, + Err(err) => { + warn!( + event_type = %observed_event_type, + ?err, + "failed to deserialize raw to-device event into JSON map" + ); + return; + } + }; + let event_value = serde_json::Value::Object(event_map); + let event = + match serde_json::from_value::(event_value.clone()) { + Ok(event) => event, + Err(err) => { + warn!( + event_type = %observed_event_type, + ?err, + raw_event = ?event_value, + "failed to parse to-device event as IncomingKeyToDeviceEvent" + ); + return; + } + }; + + if event.event_type != "io.element.call.encryption_keys" { + return; + } + + let sender_device_id = event + .content + .device_id + .as_deref() + .or_else(|| { + event + .content + .member + .as_ref() + .and_then(|member| member.claimed_device_id.as_deref()) + }) + .or_else(|| { + event + .sender_device_keys + .as_ref() + .and_then(|sender_device_keys| sender_device_keys.device_id.as_deref()) + }); + + let Some(sender_device_id) = sender_device_id else { + warn!( + sender = %event.sender, + event_room_id = %event.content.room_id, + expected_room_id = %room_id, + "ignoring encryption key event without a sender device id" + ); + return; + }; + + debug!( + sender = %event.sender, + sender_device = %sender_device_id, + event_room_id = %event.content.room_id, + expected_room_id = %room_id, + key_count = event.content.keys.len(), + "received io.element.call.encryption_keys to-device event" + ); + if event.content.room_id != room_id.as_str() { + warn!( + sender = %event.sender, + sender_device = %sender_device_id, + event_room_id = %event.content.room_id, + expected_room_id = %room_id, + "ignoring encryption key event for different room" + ); + return; + } + + let identity = ParticipantIdentity(format!("{}:{}", event.sender, sender_device_id)); + for key_entry in event.content.keys { + let key_bytes = STANDARD_NO_PAD + .decode(&key_entry.key) + .or_else(|_| STANDARD.decode(&key_entry.key)) + .or_else(|_| URL_SAFE_NO_PAD.decode(&key_entry.key)) + .or_else(|_| URL_SAFE.decode(&key_entry.key)); + let Ok(key_bytes) = key_bytes else { + warn!( + %identity, + key_index = key_entry.index, + "failed to decode per-participant E2EE key" + ); + continue; + }; + let key_set = key_provider.set_key(&identity, key_entry.index, key_bytes); + info!( + %identity, + key_index = key_entry.index, + key_set, + "installed per-participant E2EE key from to-device event" + ); + } + } + }); + + client.event_handler_drop_guard(handle) +} + +#[derive(Deserialize)] +struct IncomingKeyToDeviceEvent { + #[serde(rename = "type")] + event_type: String, + sender: String, + content: IncomingKeyToDeviceContent, + sender_device_keys: Option, +} + +#[derive(Deserialize)] +struct IncomingKeyToDeviceContent { + room_id: String, + device_id: Option, + member: Option, + #[serde(deserialize_with = "deserialize_key_entries")] + keys: Vec, +} + +#[derive(Deserialize)] +struct IncomingKeyMember { + claimed_device_id: Option, +} + +#[derive(Deserialize)] +struct IncomingSenderDeviceKeys { + device_id: Option, +} + +#[derive(Deserialize)] +struct IncomingKeyEntry { + index: i32, + key: String, +} + +fn deserialize_key_entries<'de, D>(deserializer: D) -> Result, D::Error> +where + D: serde::Deserializer<'de>, +{ + #[derive(Deserialize)] + #[serde(untagged)] + enum Keys { + One(IncomingKeyEntry), + Many(Vec), + } + + match Keys::deserialize(deserializer)? { + Keys::One(entry) => Ok(vec![entry]), + Keys::Many(entries) => Ok(entries), + } +} + +/// Resend keys on selected LiveKit room events. +pub fn spawn_livekit_e2ee_event_resend( + room: Room, + mut events: tokio::sync::mpsc::UnboundedReceiver, + context: PerParticipantE2eeContext, +) { + tokio::spawn(async move { + while let Some(event) = events.recv().await { + match event { + RoomEvent::Reconnected => { + let _ = send_per_participant_keys( + &room, + context.key_index, + &context.local_key, + None, + ) + .await; + } + RoomEvent::ParticipantConnected(participant) + | RoomEvent::TrackPublished { participant, .. } + | RoomEvent::TrackSubscribed { participant, .. } => { + let target_device_id = participant + .identity() + .as_str() + .rsplit_once(':') + .map(|(_, device_id)| device_id.to_owned()); + let _ = send_per_participant_keys( + &room, + context.key_index, + &context.local_key, + target_device_id.as_deref(), + ) + .await; + } + _ => {} + } + } + }); +} + +/// Read per-participant grace period from an env var. +pub fn per_participant_key_grace_period_from_env(var: &str, default_ms: u64) -> Duration { + let grace_ms = + std::env::var(var).ok().and_then(|value| value.parse::().ok()).unwrap_or(default_ms); + Duration::from_millis(grace_ms) +} + +#[cfg(test)] +mod tests { + use std::time::Duration; + + use super::{ + E2eeRoomOptionsProvider, derive_per_participant_key, + per_participant_key_grace_period_from_env, + }; + use crate::LiveKitRoomOptionsProvider; + + #[test] + fn derive_per_participant_key_returns_expected_length() { + let key = derive_per_participant_key(); + + assert_eq!(key.len(), 16); + assert!(key.iter().any(|byte| *byte != 0)); + } + + #[test] + fn room_options_provider_without_context_leaves_encryption_disabled() { + let provider = E2eeRoomOptionsProvider { e2ee: None }; + let options = provider.room_options(); + + assert!(options.encryption.is_none()); + } + + #[test] + fn per_participant_key_grace_period_from_env_uses_default_on_missing_or_invalid_values() { + let missing_var = "MATRIX_SDK_LIVEKIT_TEST_GRACE_PERIOD_MISSING"; + let invalid_var = "MATRIX_SDK_LIVEKIT_TEST_GRACE_PERIOD_INVALID"; + + // SAFETY: Tests are the only callers using these dedicated variable names. + unsafe { std::env::remove_var(missing_var) }; + // SAFETY: Tests are the only callers using these dedicated variable names. + unsafe { std::env::set_var(invalid_var, "not-a-number") }; + + assert_eq!( + per_participant_key_grace_period_from_env(missing_var, 500), + Duration::from_millis(500) + ); + assert_eq!( + per_participant_key_grace_period_from_env(invalid_var, 750), + Duration::from_millis(750) + ); + } + + #[test] + fn per_participant_key_grace_period_from_env_uses_valid_value() { + let var = "MATRIX_SDK_LIVEKIT_TEST_GRACE_PERIOD_VALID"; + + // SAFETY: Tests are the only callers using these dedicated variable names. + unsafe { std::env::set_var(var, "1200") }; + + assert_eq!( + per_participant_key_grace_period_from_env(var, 300), + Duration::from_millis(1200) + ); + } +} diff --git a/crates/matrix-sdk/src/widget/element_call.rs b/crates/matrix-sdk/src/widget/element_call.rs new file mode 100644 index 00000000000..5a71399b71a --- /dev/null +++ b/crates/matrix-sdk/src/widget/element_call.rs @@ -0,0 +1,518 @@ +// Copyright 2023 The Matrix.org Foundation C.I.C. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Element Call specific widget helpers. + +use std::{ + collections::HashMap, + sync::{Arc, Mutex}, + time::{SystemTime, UNIX_EPOCH}, +}; + +use ruma::{ + events::call::member::{ + ActiveFocus, ActiveLivekitFocus, Application, CallApplicationContent, + CallMemberEventContent, CallMemberStateKey, CallScope, Focus, LivekitFocus, + }, + events::{MessageLikeEventType, StateEventType}, + DeviceId, RoomId, UserId, +}; +use serde::Serialize; +use serde_json::{json, Value as JsonValue}; +use tokio::sync::{oneshot, watch}; +use tracing::info; + +use super::{ + Capabilities, ClientProperties, EncryptionSystem, Filter, Intent, MessageLikeEventFilter, + StateEventFilter, StaticCapabilitiesProvider, ToDeviceEventFilter, + VirtualElementCallWidgetConfig, VirtualElementCallWidgetProperties, WidgetDriver, + WidgetDriverHandle, WidgetSettings, +}; +use crate::{room::Room, Error, Result}; + +/// Runtime handle and state for a started Element Call widget. +#[derive(Clone, Debug)] +pub struct ElementCallWidget { + handle: WidgetDriverHandle, + widget_id: String, + capabilities_ready: watch::Receiver, + pending_widget_responses: Arc>>>, +} + +impl ElementCallWidget { + /// Access the driver handle used to send/receive widget messages. + pub fn handle(&self) -> &WidgetDriverHandle { + &self.handle + } + + /// The widget id used by this widget instance. + pub fn widget_id(&self) -> &str { + &self.widget_id + } + + /// A watch channel that flips to `true` after capability negotiation. + pub fn capabilities_ready(&self) -> watch::Receiver { + self.capabilities_ready.clone() + } + + /// Track a request id and return a receiver for the corresponding widget response. + pub fn track_pending_response(&self, request_id: String) -> oneshot::Receiver { + let (tx, rx) = oneshot::channel(); + if let Ok(mut pending) = self.pending_widget_responses.lock() { + pending.insert(request_id, tx); + } + rx + } + + /// Stop tracking a request id. + pub fn remove_pending_response(&self, request_id: &str) { + if let Ok(mut pending) = self.pending_widget_responses.lock() { + pending.remove(request_id); + } + } +} + +/// Additional options used to initialize a virtual Element Call widget. +#[derive(Debug)] +pub struct ElementCallWidgetOptions { + /// The widget id used in widget-api messages. + pub widget_id: String, + /// The parent URL used as postMessage target. + pub parent_url: Option, + /// Encryption mode for Element Call. + pub encryption: EncryptionSystem, + /// Join/start intent for Element Call. + pub intent: Intent, + /// Client properties used for URL generation. + pub client_properties: ClientProperties, +} + +impl Default for ElementCallWidgetOptions { + fn default() -> Self { + Self { + widget_id: "element-call".to_owned(), + parent_url: None, + encryption: EncryptionSystem::PerParticipantKeys, + intent: Intent::JoinExisting, + client_properties: ClientProperties::new("matrix-rust-sdk", None, None), + } + } +} + +/// Start a virtual Element Call widget backed by a [`WidgetDriver`]. +pub async fn start_element_call_widget( + room: Room, + element_call_url: String, + options: ElementCallWidgetOptions, +) -> Result { + let own_user_id = room + .client() + .user_id() + .ok_or_else(|| { + Error::UnknownError( + std::io::Error::other("missing user id for element call widget").into(), + ) + })? + .to_owned(); + let own_device_id = room + .client() + .device_id() + .ok_or_else(|| { + Error::UnknownError( + std::io::Error::other("missing device id for element call widget").into(), + ) + })? + .to_owned(); + + let props = VirtualElementCallWidgetProperties { + element_call_url, + widget_id: options.widget_id, + parent_url: options.parent_url, + encryption: options.encryption, + ..Default::default() + }; + let config = + VirtualElementCallWidgetConfig { intent: Some(options.intent), ..Default::default() }; + + let widget_settings = WidgetSettings::new_virtual_element_call_widget(props, config)?; + let widget_id = widget_settings.widget_id().to_owned(); + let widget_url = widget_settings.generate_webview_url(&room, options.client_properties).await?; + info!(%widget_url, "element call widget url"); + info!(widget_id = %widget_settings.widget_id(), "starting Element Call widget driver"); + + let (driver, handle) = WidgetDriver::new(widget_settings); + let capabilities = element_call_capabilities(&own_user_id, &own_device_id); + let capabilities_provider = StaticCapabilitiesProvider::new(capabilities); + let widget_capabilities = capabilities_provider.capabilities().clone(); + let (capabilities_ready_tx, capabilities_ready_rx) = watch::channel(false); + let pending_widget_responses: Arc>>> = + Arc::new(Mutex::new(HashMap::new())); + tokio::spawn(async move { + if driver.run(room, capabilities_provider).await.is_err() { + info!("element call widget driver stopped"); + } + }); + + let outbound_handle = handle.clone(); + let outbound_widget_id = widget_id.clone(); + let pending_widget_responses_for_task = pending_widget_responses.clone(); + tokio::spawn(async move { + let capabilities_ready_tx = capabilities_ready_tx; + let pending_widget_responses = pending_widget_responses_for_task; + while let Some(message) = outbound_handle.recv().await { + let Ok(value) = serde_json::from_str::(&message) else { + continue; + }; + let Some(request_id) = value.get("requestId").and_then(|v| v.as_str()) else { + continue; + }; + if value.get("response").is_some() { + if let Some(tx) = pending_widget_responses + .lock() + .ok() + .and_then(|mut pending| pending.remove(request_id)) + { + let _ = tx.send(value); + } + continue; + } + let Some(action) = value.get("action").and_then(|v| v.as_str()) else { + continue; + }; + let api = value.get("api").and_then(|v| v.as_str()); + if api != Some("toWidget") { + continue; + } + if action == "capabilities" { + let response = serde_json::json!({ + "api": "toWidget", + "widgetId": outbound_widget_id, + "requestId": request_id, + "action": "capabilities", + "data": {}, + "response": { + "capabilities": widget_capabilities, + }, + }); + if !outbound_handle.send(response.to_string()).await { + break; + } + } + if action == "notify_capabilities" { + let response = serde_json::json!({ + "api": "toWidget", + "widgetId": outbound_widget_id, + "requestId": request_id, + "action": "notify_capabilities", + "data": {}, + "response": {}, + }); + if !outbound_handle.send(response.to_string()).await { + break; + } + let _ = capabilities_ready_tx.send(true); + } + if action == "send_to_device" { + let data = value.get("data").cloned().unwrap_or_else(|| serde_json::json!({})); + let event_type = data + .get("event_type") + .and_then(|v| v.as_str()) + .or_else(|| data.get("type").and_then(|v| v.as_str())); + if event_type == Some("io.element.call.encryption_keys") { + info!(request_id, payload = %data, "widget send_to_device encryption key payload"); + } else { + info!(request_id, event_type, "widget send_to_device received"); + } + } + } + info!("widget -> rust-sdk message stream closed"); + }); + + let content_loaded = serde_json::json!({ + "api": "fromWidget", + "widgetId": widget_id, + "requestId": format!( + "content-loaded-{}", + SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default().as_millis() + ), + "action": "content_loaded", + "data": {}, + }); + let _ = handle.send(content_loaded.to_string()).await; + + Ok(ElementCallWidget { + handle, + widget_id, + capabilities_ready: capabilities_ready_rx, + pending_widget_responses, + }) +} + +/// Build the default Element Call capability set used by SDK-driven widgets. +pub fn element_call_capabilities(own_user_id: &UserId, own_device_id: &DeviceId) -> Capabilities { + let read_send = vec![ + Filter::MessageLike(MessageLikeEventFilter::WithType(MessageLikeEventType::from( + "org.matrix.rageshake_request", + ))), + Filter::ToDevice(ToDeviceEventFilter::new("io.element.call.encryption_keys".into())), + Filter::MessageLike(MessageLikeEventFilter::WithType(MessageLikeEventType::from( + "io.element.call.encryption_keys", + ))), + Filter::MessageLike(MessageLikeEventFilter::WithType(MessageLikeEventType::from( + "io.element.call.reaction", + ))), + Filter::MessageLike(MessageLikeEventFilter::WithType(MessageLikeEventType::Reaction)), + Filter::MessageLike(MessageLikeEventFilter::WithType(MessageLikeEventType::RoomRedaction)), + Filter::MessageLike(MessageLikeEventFilter::WithType(MessageLikeEventType::RtcDecline)), + ]; + + let user_id = own_user_id.as_str(); + let device_id = own_device_id.as_str(); + let membership_state_key = CallMemberStateKey::new( + own_user_id.to_owned(), + Some(format!("{own_device_id}_m.call")), + false, + ) + .as_ref() + .to_owned(); + + Capabilities { + read: vec![ + Filter::State(StateEventFilter::WithType(StateEventType::CallMember)), + Filter::State(StateEventFilter::WithType(StateEventType::RoomName)), + Filter::State(StateEventFilter::WithType(StateEventType::RoomMember)), + Filter::State(StateEventFilter::WithType(StateEventType::RoomEncryption)), + Filter::State(StateEventFilter::WithType(StateEventType::RoomCreate)), + ] + .into_iter() + .chain(read_send.clone()) + .collect(), + send: vec![ + Filter::MessageLike(MessageLikeEventFilter::WithType( + MessageLikeEventType::RtcNotification, + )), + Filter::MessageLike(MessageLikeEventFilter::WithType(MessageLikeEventType::CallNotify)), + Filter::State(StateEventFilter::WithTypeAndStateKey( + StateEventType::CallMember, + user_id.to_owned(), + )), + Filter::State(StateEventFilter::WithTypeAndStateKey( + StateEventType::CallMember, + format!("{user_id}_{device_id}"), + )), + Filter::State(StateEventFilter::WithTypeAndStateKey( + StateEventType::CallMember, + membership_state_key, + )), + Filter::State(StateEventFilter::WithTypeAndStateKey( + StateEventType::CallMember, + format!("{user_id}_{device_id}_m.call"), + )), + Filter::State(StateEventFilter::WithTypeAndStateKey( + StateEventType::CallMember, + format!("_{user_id}_{device_id}"), + )), + Filter::State(StateEventFilter::WithTypeAndStateKey( + StateEventType::CallMember, + format!("_{user_id}_{device_id}_m.call"), + )), + ] + .into_iter() + .chain(read_send) + .collect(), + requires_client: true, + update_delayed_event: true, + send_delayed_event: true, + } +} + +/// Build `m.call.member` content suitable for publishing through the widget API. +pub fn element_call_member_content( + room_id: &RoomId, + own_device_id: &DeviceId, + service_url: &str, +) -> CallMemberEventContent { + let application = + Application::Call(CallApplicationContent::new("".to_owned(), CallScope::Room)); + let focus_active = ActiveFocus::Livekit(ActiveLivekitFocus::new()); + let foci_preferred = + vec![Focus::Livekit(LivekitFocus::new(room_id.to_string(), service_url.to_owned()))]; + + CallMemberEventContent::new( + application, + own_device_id.to_owned(), + focus_active, + foci_preferred, + None, + None, + ) +} + +/// Build a `fromWidget` `send_event` request payload for `m.call.member`. +pub fn element_call_send_event_message( + widget_id: &str, + request_id: &str, + state_key: &str, + content: &impl Serialize, +) -> JsonValue { + json!({ + "api": "fromWidget", + "widgetId": widget_id, + "requestId": request_id, + "action": "send_event", + "data": { + "type": "org.matrix.msc3401.call.member", + "state_key": state_key, + "content": content, + }, + }) +} + +/// Publish `m.call.member` through the widget API for the current user/device. +pub async fn publish_call_membership_via_widget( + room: Room, + widget: &ElementCallWidget, + service_url: &str, +) -> Result<()> { + if !*widget.capabilities_ready().borrow() { + let mut capabilities_ready = widget.capabilities_ready(); + let _ = capabilities_ready.changed().await; + } + + let own_user_id = room + .client() + .user_id() + .ok_or_else(|| { + Error::UnknownError( + std::io::Error::other("missing user id for widget membership publisher").into(), + ) + })? + .to_owned(); + let own_device_id = room + .client() + .device_id() + .ok_or_else(|| { + Error::UnknownError( + std::io::Error::other("missing device id for widget membership publisher").into(), + ) + })? + .to_owned(); + + let state_key = + CallMemberStateKey::new(own_user_id.clone(), Some(own_device_id.to_string()), true); + let content = element_call_member_content(room.room_id(), &own_device_id, service_url); + let request_id = SystemTime::now() + .duration_since(UNIX_EPOCH) + .map(|d| d.as_nanos().to_string()) + .unwrap_or_else(|_| "0".to_owned()); + let send_event_message = element_call_send_event_message( + widget.widget_id(), + &request_id, + state_key.as_ref(), + &content, + ); + + let send_event_message_json = send_event_message.to_string(); + info!( + request_body = send_event_message_json.as_str(), + "Publishing MatrixRTC membership send_event via widget api" + ); + + if !widget.handle().send(send_event_message.to_string()).await { + return Err(Error::UnknownError( + std::io::Error::other( + "widget driver handle closed before sending membership send_event", + ) + .into(), + )); + } + + info!(state_key = state_key.as_ref(), "published MatrixRTC membership via widget api"); + Ok(()) +} + +/// Send an empty `m.call.member` event through the widget API to shut down membership. +pub async fn send_hangup_via_widget( + widget: &ElementCallWidget, + state_key: Option<&CallMemberStateKey>, +) -> Result<()> { + const SHUTDOWN_WIDGET_WAIT_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(2); + + if !*widget.capabilities_ready().borrow() { + let mut capabilities_ready = widget.capabilities_ready(); + let _ = + tokio::time::timeout(SHUTDOWN_WIDGET_WAIT_TIMEOUT, capabilities_ready.changed()).await; + } + + let request_id = SystemTime::now() + .duration_since(UNIX_EPOCH) + .map(|d| d.as_nanos().to_string()) + .unwrap_or_else(|_| "0".to_owned()); + let response_rx = widget.track_pending_response(request_id.clone()); + let state_key = state_key.map(|state_key| state_key.as_ref()).unwrap_or_default(); + let shutdown_message = element_call_send_event_message( + widget.widget_id(), + &request_id, + state_key, + &serde_json::json!({}), + ); + info!( + request_body = shutdown_message.to_string().as_str(), + "sending shutdown membership send_event via widget api" + ); + + match tokio::time::timeout( + SHUTDOWN_WIDGET_WAIT_TIMEOUT, + widget.handle().send(shutdown_message.to_string()), + ) + .await + { + Ok(true) => info!("shutdown membership send_event sent via widget api"), + Ok(false) => { + widget.remove_pending_response(&request_id); + return Err(Error::UnknownError( + std::io::Error::other( + "widget driver handle closed before sending shutdown membership send_event", + ) + .into(), + )); + } + Err(_) => { + widget.remove_pending_response(&request_id); + info!( + "timeout while sending shutdown membership send_event via widget api; continuing shutdown" + ); + return Ok(()); + } + } + + match tokio::time::timeout(SHUTDOWN_WIDGET_WAIT_TIMEOUT, response_rx).await { + Ok(Ok(_response)) => { + info!(request_id, "received widget response for shutdown membership send_event") + } + Ok(Err(_)) => info!( + request_id, + "shutdown membership send_event response channel closed; continuing shutdown" + ), + Err(_) => { + widget.remove_pending_response(&request_id); + info!( + request_id, + "timeout waiting for widget shutdown membership send_event response; continuing shutdown" + ); + } + } + + Ok(()) +} diff --git a/examples/rtc_livekit_join/Cargo.toml b/examples/rtc_livekit_join/Cargo.toml new file mode 100644 index 00000000000..eae8b05b0a7 --- /dev/null +++ b/examples/rtc_livekit_join/Cargo.toml @@ -0,0 +1,52 @@ +[package] +name = "example-rtc-livekit-join" +version = "0.1.0" +edition = "2024" +publish = false +license = "Apache-2.0" + +[package.metadata.release] +release = false + +[[bin]] +name = "example-rtc-livekit-join" +test = false + +[dependencies] +anyhow.workspace = true +async-trait.workspace = true +base64.workspace = true +futures-util.workspace = true +mime.workspace = true +matrix-sdk = { path = "../../crates/matrix-sdk", default-features = false, features = ["e2e-encryption", "experimental-send-custom-to-device"] } +matrix-sdk-base = { path = "../../crates/matrix-sdk-base" } +matrix-sdk-crypto = { path = "../../crates/matrix-sdk-crypto" } +matrix-sdk-rtc-livekit = { path = "../../crates/matrix-sdk-rtc-livekit", default-features = false } +reqwest.workspace = true +ruma.workspace = true +serde.workspace = true +serde_json.workspace = true +sha2.workspace = true +tokio = { workspace = true, features = ["macros", "rt-multi-thread"] } +tracing.workspace = true +tracing-subscriber.workspace = true +url.workspace = true +uuid.workspace = true +v4l = { version = "0.14", optional = true } +rand = { version = "0.8.0" } +zeromq = { version = "0.4", default-features = false, features = ["tcp-transport", "tokio-runtime"] } +jpeg-decoder = "0.3" +axum = "0.8.1" +pulldown-cmark = "0.9" +once_cell = "1.20.3" + +[lints] +workspace = true + +[features] +default = [] +rustls-tls = ["matrix-sdk/rustls-tls", "matrix-sdk-rtc-livekit/rustls-tls"] +native-tls = ["matrix-sdk/native-tls", "matrix-sdk-rtc-livekit/native-tls"] +v4l2 = ["dep:v4l"] +experimental-widgets = ["matrix-sdk/experimental-widgets", "matrix-sdk-rtc-livekit/experimental-widgets"] +sqlite = ["matrix-sdk/sqlite"] diff --git a/examples/rtc_livekit_join/README.md b/examples/rtc_livekit_join/README.md new file mode 100644 index 00000000000..5785c5f4922 --- /dev/null +++ b/examples/rtc_livekit_join/README.md @@ -0,0 +1,82 @@ +# LiveKit call join (skeleton) + +This example shows how to use `matrix-sdk-rtc-livekit` to +join/leave a LiveKit room with Element-Call based SFrame Encryption based on MatrixRTC call memberships. + +**Important:** this example needs MatrixRTC memberships (e.g. `m.call.member`) +for your device before the LiveKit room driver will connect. + +## What this example does + +1. Logs into Matrix. (HOMESERVER_URL, MATRIX_USERNAME and MATRIX_PASSWORD) +2. Backup from local CryptoStore if exists (MATRIX_RECOVERY_KEY) +3. Joins the target room (ROOM_ID) +4. Start the sync loop to collect Participant Keys +5. Send Membership Event and emit own Participant Key via Widget API +6. Runs the LiveKit room driver, which connects to LiveKit when the room has active + call memberships and disconnects when they disappear. +7. With active connection to LiveKit Room the local Camera will be feeded into Element Call via V4L2 + +## What is working and what not? + +- [x] Usage of Linux based Video Sources with V4L2 (also working with Embedded Linux Distros) +- [ ] Usage of Video Sources from other OSes +- [ ] Usage of Microphones +- [ ] Increase of Ratchet Index on Group Membership Change + +## Usage + +Configuration of the example happens with this environment variables: + +### Mandatory Variables + +```bash +HOMESERVER_URL=https://matrix.example.org \ +MATRIX_USERNAME=@alice:example.org \ +MATRIX_PASSWORD=secret \ +ROOM_ID=!roomid:example.org \ +ELEMENT_CALL_URL=https://webclient.matrix.example.org +``` + +### Optional Variables for Connection + +```bash +MATRIX_RECOVERY_KEY="recov ery key client exam ple" +LIVEKIT_TOKEN=your-token \ +LIVEKIT_SFU_GET_URL=https://demo.call.bundesmessenger.info/sfu/get \ +LIVEKIT_SERVICE_URL=wss://livekit.example.org \ +``` + +### Optional Variables for Video Feeding + +```bash +V4L2_DEVICE=/dev/video0 \ +V4L2_VIDEO_SOURCE=camera \ +V4L2_WIDTH=1280 \ +V4L2_HEIGHT=720 \ +``` + +To publish generated solid red test frames instead of a real camera stream, set +`V4L2_VIDEO_SOURCE=test_red` (or `test-red` / `red`). In this mode, `V4L2_DEVICE` +is optional and defaults to 640x480 when width/height are omitted. + +### Optional Variables for Participant Key Provision + +We have option for resend interval for own participant key. For now the Ratchet isn't increasing for Group Membership changes. + +```bash +PER_PARTICIPANT_KEY_RESEND_SECS=30 +``` + + +## Build notes (Linux) + +The LiveKit/WebRTC dependency currently links against libstdc++. If you build +with `clang`/`libc++`, you may see undefined references like +`std::__throw_bad_array_new_length()` or `std::__glibcxx_assert_fail`. + +I had best compability over multiple different platforms by using gcc-13 with g++-13: + +``` +CC=gcc-13 CXX=g++-13 cargo build -p example-rtc-livekit-join --features rustls-tls --features v4l2,matrix-sdk/experimental-widgets,experimental-widgets,sqlite +``` diff --git a/examples/rtc_livekit_join/src/main.rs b/examples/rtc_livekit_join/src/main.rs new file mode 100644 index 00000000000..ea7a1a46647 --- /dev/null +++ b/examples/rtc_livekit_join/src/main.rs @@ -0,0 +1,455 @@ +#![recursion_limit = "256"] + +use matrix_sdk::{ + config::SyncSettings, + room::Room, + ruma::{RoomId, RoomOrAliasId}, + Client, RoomState, +}; +use std::sync::Arc; +use std::time::Duration; +use std::{env, fs}; + +use matrix_sdk::encryption::secret_storage::SecretStore; + +use anyhow::{anyhow, Context}; +#[cfg(feature = "experimental-widgets")] +use matrix_sdk_rtc_livekit::element_call::{ + start_element_call_widget_for_room, LiveKitElementCallWidget, +}; +use matrix_sdk_rtc_livekit::per_participant::{ + handle_per_participant_joined, prepare_per_participant_e2ee, PerParticipantE2eeContext, +}; +use matrix_sdk_rtc_livekit::{ + prepare_livekit_sdk_connector, run_livekit_driver_joined_left, LiveKitRoomOptionsProvider, + Room as LivekitRoom, LiveKitError, LiveKitResult, +}; +use tracing::{info, warn}; +#[cfg(all(feature = "v4l2", target_os = "linux"))] +mod videosource; +#[cfg(all(feature = "v4l2", target_os = "linux"))] +use videosource::{v4l2_config_from_env, V4l2CameraPublisher, V4l2Config, V4l2PublishError}; + +#[cfg(not(all(feature = "v4l2", target_os = "linux")))] +fn v4l2_config_from_env() -> anyhow::Result<()> { + Ok(()) +} + +#[tokio::main] +async fn main() -> anyhow::Result<()> { + tracing_subscriber::fmt::init(); + + // collecting matrix specific config variables + let homeserver_url = required_env("HOMESERVER_URL")?; + let username = required_env("MATRIX_USERNAME")?; + let password = required_env("MATRIX_PASSWORD")?; + let device_id = optional_env("MATRIX_DEVICE_ID"); + let secret_key = optional_env("MATRIX_RECOVERY_KEY"); + let store_dir = env::current_dir().context("read current directory")?.join("matrix-sdk-store"); + prepare_sqlite_store_dir(&store_dir)?; + + // deriving matrix client from succesful login + let client = login( + &homeserver_url, + &username, + &password, + device_id.as_deref(), + Some(&store_dir), + "matrix-bot", + ) + .await?; + + let secret_store = client + .encryption() + .secret_storage() + .open_secret_store(secret_key.as_deref().unwrap()) + .await?; + import_known_secrets(&client, secret_store).await?; + + let sync_handle = tokio::spawn({ + let client = client.clone(); + async move { sync(client).await } + }); + + let rtc = run_rtc_livekit_join(client.clone()).await?; + rtc.set_call_active(true).await?; + + //tokio::signal::ctrl_c().await.context("wait for ctrl+c")?; + // info!("received ctrl+c; shutting down rtc client"); + + tokio::time::sleep(Duration::from_secs(10)).await; + rtc.set_call_active(false).await?; + rtc.shutdown().await; + + tokio::time::sleep(Duration::from_secs(10)).await; + + let rtc = run_rtc_livekit_join(client.clone()).await?; + rtc.set_call_active(true).await?; + + //tokio::signal::ctrl_c().await.context("wait for ctrl+c")?; + //info!("received ctrl+c; shutting down rtc client"); + + tokio::time::sleep(Duration::from_secs(10)).await; + rtc.set_call_active(false).await?; + rtc.shutdown().await; + + sync_handle.abort(); + Ok(()) +} + +async fn login( + homeserver_url: &str, + username: &str, + password: &str, + device_id: Option<&str>, + store_dir: Option<&std::path::Path>, + initial_device_display_name: &str, +) -> anyhow::Result { + let mut client_builder = Client::builder().homeserver_url(homeserver_url); + + if let Some(store_dir) = store_dir { + #[cfg(feature = "sqlite")] + { + client_builder = client_builder.sqlite_store(store_dir, None); + } + #[cfg(not(feature = "sqlite"))] + { + let _ = store_dir; + warn!("sqlite feature disabled; crypto store will be in-memory."); + } + } + + let client = client_builder.build().await.context("build Matrix client")?; + + let mut login_builder = client + .matrix_auth() + .login_username(username, password) + .initial_device_display_name(initial_device_display_name); + + if let Some(device_id) = device_id { + login_builder = login_builder.device_id(device_id); + } + + login_builder.send().await.context("login Matrix user")?; + + // It worked! + println!("logged in as {username}"); + + Ok(client) +} + +fn prepare_sqlite_store_dir(store_dir: &std::path::Path) -> anyhow::Result<()> { + if store_dir.is_file() { + warn!( + store_path = %store_dir.display(), + "Removing file that conflicts with sqlite store directory." + ); + fs::remove_file(store_dir).context("remove sqlite store file")?; + } + fs::create_dir_all(store_dir).context("create crypto store directory")?; + + let legacy_store_path = store_dir.join("matrix-sdk.sqlite"); + if legacy_store_path.exists() { + warn!( + store_path = %legacy_store_path.display(), + "Removing legacy sqlite file path." + ); + if legacy_store_path.is_dir() { + fs::remove_dir_all(&legacy_store_path).context("remove legacy sqlite directory")?; + } else { + fs::remove_file(&legacy_store_path).context("remove legacy sqlite file")?; + } + } + + for sqlite_file in [ + "matrix-sdk-state.sqlite3", + "matrix-sdk-crypto.sqlite3", + "matrix-sdk-event-cache.sqlite3", + "matrix-sdk-media.sqlite3", + ] { + let db_path = store_dir.join(sqlite_file); + if db_path.is_file() { + let header = fs::read(&db_path) + .context("read sqlite header")? + .into_iter() + .take(16) + .collect::>(); + if header != b"SQLite format 3\0" { + warn!( + store_path = %db_path.display(), + "Removing invalid sqlite store file." + ); + fs::remove_file(&db_path).context("remove invalid sqlite file")?; + } + } + } + + Ok(()) +} + +// sync is necessary for call to collect other participants encryption_keys events +async fn sync(client: Client) -> anyhow::Result<()> { + let sync_token = client.sync_once(SyncSettings::default()).await.unwrap().next_batch; + + // since we called `sync_once` before we entered our sync loop we must pass + // that sync token to `sync` + let settings = SyncSettings::default().token(sync_token); + client.sync(settings).await?; // this essentially loops until we kill the bot + + Ok(()) +} + +async fn import_known_secrets(client: &Client, secret_store: SecretStore) -> anyhow::Result<()> { + secret_store.import_secrets().await?; + + let status = client + .encryption() + .cross_signing_status() + .await + .expect("We should be able to get our cross-signing status"); + + if status.is_complete() { + println!("Successfully imported all the cross-signing keys"); + } else { + eprintln!("Couldn't import all the cross-signing keys: {status:?}"); + } + + Ok(()) +} + +async fn run_rtc_livekit_join(client: Client) -> anyhow::Result { + let room_id_or_alias = required_env("ROOM_ID")?; + let livekit_service_url_override = optional_env("LIVEKIT_SERVICE_URL"); + let livekit_sfu_get_url = optional_env("LIVEKIT_SFU_GET_URL"); + let v4l2_config = v4l2_config_from_env().context("read V4L2 config")?; + + let room_id_or_alias = RoomOrAliasId::parse(room_id_or_alias).context("parse ROOM_ID")?; + let room = match RoomId::parse(room_id_or_alias.as_str()) { + Ok(room_id) => match client.get_room(&room_id) { + Some(room) if room.state() == RoomState::Joined => room, + _ => client.join_room_by_id(&room_id).await.context("join room")?, + }, + // We intentionally do not provide via servers from env in this example. + Err(_) => { + client.join_room_by_id_or_alias(&room_id_or_alias, &[]).await.context("join room")? + } + }; + let element_call_url = optional_env("ELEMENT_CALL_URL"); + #[cfg(feature = "experimental-widgets")] + let widget = if let Some(element_call_url) = element_call_url { + info!(%element_call_url, "Element Call widget URL set; starting widget bridge"); + + Some( + start_element_call_widget_for_room(room.clone(), element_call_url) + .await + .context("start element call widget")?, + ) + } else { + None + }; + + #[cfg(not(feature = "experimental-widgets"))] + let widget: Option<()> = None; + + let static_livekit_token = optional_env("LIVEKIT_TOKEN"); + let prepared_e2ee = prepare_per_participant_e2ee( + &room, + retry_seconds_from_env("PER_PARTICIPANT_KEY_RESEND_SECS", 0), + ) + .await?; + let room_options_provider = prepared_e2ee.room_options_provider; + let resolved_room_options = room_options_provider.room_options(); + info!( + room_options_provider_type = std::any::type_name_of_val(&room_options_provider), + room_options = ?resolved_room_options, + has_encryption_key_provider = resolved_room_options.encryption.is_some(), + "configured LiveKit room options provider" + ); + let prepared_livekit = prepare_livekit_sdk_connector( + &client, + &room, + livekit_sfu_get_url.as_deref(), + livekit_service_url_override.as_deref(), + static_livekit_token.as_deref(), + room_options_provider, + ) + .await + .context("prepare LiveKit SDK connector")?; + let service_url = prepared_livekit.service_url.clone(); + let token_len = prepared_livekit.token_len; + let e2ee_context_for_driver = prepared_e2ee.context; + + info!( + room_id = ?room.room_id(), + service_url = %service_url, + token_len, + "starting LiveKit driver" + ); + + let room_for_driver = room.clone(); + let service_url_for_driver = service_url.clone(); + let driver_handle = tokio::spawn(async move { + run_livekit_driver_joined_left( + room_for_driver, + &prepared_livekit.connector, + &service_url_for_driver, + build_driver_state( + room, + #[cfg(all(feature = "v4l2", target_os = "linux"))] + v4l2_config, + e2ee_context_for_driver, + ), + |mut state, room_handle, events| async move { + info!(room_name = %room_handle.name(), "LiveKit room connected"); + let livekit_events = events; + handle_per_participant_joined( + &state.room, + &room_handle, + livekit_events, + state.e2ee_context.as_ref(), + "PER_PARTICIPANT_KEY_GRACE_PERIOD_MS", + 300, + ) + .await; + set_video_stream_enabled(&mut state, Some(room_handle), true).await?; + Ok(state) + }, + |mut state| async move { + set_video_stream_enabled(&mut state, None, false).await?; + Ok(state) + }, + ) + .await + .context("run LiveKit room driver") + }); + + Ok(RtcLiveKitRuntime { + service_url, + #[cfg(feature = "experimental-widgets")] + widget, + driver_handle, + }) +} + +struct RtcLiveKitRuntime { + service_url: String, + #[cfg(feature = "experimental-widgets")] + widget: Option, + driver_handle: tokio::task::JoinHandle>, +} + +// toggle between call participating by publishing membership event or send hangup event +impl RtcLiveKitRuntime { + async fn set_call_active(&self, active: bool) -> anyhow::Result<()> { + #[cfg(feature = "experimental-widgets")] + { + if let Some(widget) = self.widget.as_ref() { + if active { + widget + .publish_membership(self.service_url.as_str()) + .await + .context("publish MatrixRTC membership via widget api")?; + } else { + widget + .send_hangup() + .await + .context("send shutdown membership via widget api")?; + } + + return Ok(()); + } + } + + if active { + warn!( + "set_call_active(true) requested without experimental widget support; activation must come from room call memberships" + ); + } else { + info!( + "set_call_active(false) requested without experimental widget support; no local hangup message can be sent" + ); + } + + Ok(()) + } + + fn shutdown_call_session(&self) { + self.driver_handle.abort(); + } + + async fn shutdown(self) { + if let Err(err) = self.set_call_active(false).await { + info!(?err, "failed to deactivate call while shutting down runtime"); + } + + self.shutdown_call_session(); + + let _ = self.driver_handle.await; + } +} + +fn required_env(name: &str) -> anyhow::Result { + env::var(name).with_context(|| anyhow!("missing required env var: {name}")) +} + +fn optional_env(name: &str) -> Option { + env::var(name).ok().filter(|value| !value.trim().is_empty()) +} + +fn retry_seconds_from_env(name: &str, default: u64) -> u64 { + optional_env(name).and_then(|value| value.parse::().ok()).unwrap_or(default) +} + +struct DriverState { + room: Room, + #[cfg(all(feature = "v4l2", target_os = "linux"))] + v4l2_config: Option, + #[cfg(all(feature = "v4l2", target_os = "linux"))] + v4l2_publisher: Option, + e2ee_context: Option, +} + +fn build_driver_state( + room: Room, + #[cfg(all(feature = "v4l2", target_os = "linux"))] v4l2_config: Option, + e2ee_context: Option, +) -> DriverState { + DriverState { + room, + #[cfg(all(feature = "v4l2", target_os = "linux"))] + v4l2_config, + #[cfg(all(feature = "v4l2", target_os = "linux"))] + v4l2_publisher: None, + e2ee_context, + } +} + +async fn set_video_stream_enabled( + state: &mut DriverState, + room_handle: Option>, + enabled: bool, +) -> LiveKitResult<()> { + #[cfg(not(all(feature = "v4l2", target_os = "linux")))] + let _ = (&state, room_handle, enabled); + + #[cfg(all(feature = "v4l2", target_os = "linux"))] + { + if enabled { + if state.v4l2_publisher.is_none() { + if let (Some(room_handle), Some(config)) = + (room_handle, state.v4l2_config.as_ref().cloned()) + { + info!(device = %config.device, "starting V4L2 camera publisher"); + let publisher = V4l2CameraPublisher::start(room_handle, config) + .await + .map_err(|err| LiveKitError::connector(V4l2PublishError(err)))?; + state.v4l2_publisher = Some(publisher); + } + } + } else if let Some(mut publisher) = state.v4l2_publisher.take() { + publisher.stop().await.map_err(|err| LiveKitError::connector(V4l2PublishError(err)))?; + } + } + + Ok(()) +} diff --git a/examples/rtc_livekit_join/src/videosource.rs b/examples/rtc_livekit_join/src/videosource.rs new file mode 100644 index 00000000000..fc0198dc25e --- /dev/null +++ b/examples/rtc_livekit_join/src/videosource.rs @@ -0,0 +1,470 @@ +use std::sync::Arc; +use anyhow::{anyhow, Context}; +use matrix_sdk_rtc_livekit::Room as LivekitRoom; +use tracing::{info, warn}; +use crate::optional_env; + +#[cfg(all(feature = "v4l2", target_os = "linux"))] +#[derive(Clone, Debug)] +pub(crate) struct V4l2Config { + pub(crate) device: String, + pub(crate) width: Option, + pub(crate) height: Option, + source: V4l2VideoSource, +} + +#[cfg(all(feature = "v4l2", target_os = "linux"))] +#[derive(Copy, Clone, Debug, Default)] +enum V4l2VideoSource { + #[default] + Camera, + TestRedFrames, +} + +#[cfg(all(feature = "v4l2", target_os = "linux"))] +#[derive(Debug)] +pub(crate) struct V4l2PublishError(pub(crate) anyhow::Error); + +#[cfg(all(feature = "v4l2", target_os = "linux"))] +impl std::fmt::Display for V4l2PublishError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{:?}", self.0) + } +} + +#[cfg(all(feature = "v4l2", target_os = "linux"))] +impl std::error::Error for V4l2PublishError {} + +#[cfg(all(feature = "v4l2", target_os = "linux"))] +pub(crate) struct V4l2CameraPublisher { + room: Arc, + track: matrix_sdk_rtc_livekit::livekit::track::LocalVideoTrack, + stop_tx: Option>, + task: Option>>, +} + +#[cfg(all(feature = "v4l2", target_os = "linux"))] +#[derive(Copy, Clone, Debug)] +enum V4l2PixelFormat { + Nv12, + Yuyv, +} + +#[cfg(all(feature = "v4l2", target_os = "linux"))] +impl V4l2CameraPublisher { + pub(crate) async fn start( + room: Arc, + config: V4l2Config, + ) -> anyhow::Result { + use matrix_sdk_rtc_livekit::livekit::options::{TrackPublishOptions, VideoCodec}; + use matrix_sdk_rtc_livekit::livekit::track::{LocalTrack, TrackSource}; + use matrix_sdk_rtc_livekit::livekit::webrtc::prelude::RtcVideoSource; + + let (resolution, rtc_source, capture_mode) = + configure_v4l2_capture_mode(&config).context("configure V4L2 capture")?; + + let track = matrix_sdk_rtc_livekit::livekit::track::LocalVideoTrack::create_video_track( + "v4l2_camera", + RtcVideoSource::Native(rtc_source.clone()), + ); + + info!( + room_name = %room.name(), + "publishing V4L2 camera track" + ); + room.local_participant() + .publish_track( + LocalTrack::Video(track.clone()), + TrackPublishOptions { + source: TrackSource::Camera, + video_codec: VideoCodec::VP8, + ..Default::default() + }, + ) + .await + .context("publish V4L2 camera track")?; + + let (stop_tx, stop_rx) = std::sync::mpsc::channel(); + let task = tokio::task::spawn_blocking(move || match capture_mode { + V4l2CaptureMode::Camera { mut device, pixel_format } => run_v4l2_capture_loop( + &mut device, + resolution, + pixel_format, + rtc_source, + stop_rx, + ), + V4l2CaptureMode::TestRedFrames => { + run_generated_red_capture_loop(resolution, rtc_source, stop_rx) + } + }); + + Ok(Self { + room, + track, + stop_tx: Some(stop_tx), + task: Some(task), + }) + } + + pub(crate) async fn stop(&mut self) -> anyhow::Result<()> { + info!(room_name = %self.room.name(), "stopping V4L2 camera track"); + if let Some(stop_tx) = self.stop_tx.take() { + let _ = stop_tx.send(()); + } + if let Some(task) = self.task.take() { + let _ = task.await?; + } + self.room + .local_participant() + .unpublish_track(&self.track.sid()) + .await + .context("unpublish V4L2 camera track")?; + Ok(()) + } +} + +#[cfg(all(feature = "v4l2", target_os = "linux"))] +impl Drop for V4l2CameraPublisher { + fn drop(&mut self) { + if let Some(stop_tx) = self.stop_tx.take() { + let _ = stop_tx.send(()); + } + + if let Some(task) = self.task.take() { + task.abort(); + } + } +} + +#[cfg(all(feature = "v4l2", target_os = "linux"))] +enum V4l2CaptureMode { + Camera { device: v4l::Device, pixel_format: V4l2PixelFormat }, + TestRedFrames, +} + +#[cfg(all(feature = "v4l2", target_os = "linux"))] +fn configure_v4l2_capture_mode( + config: &V4l2Config, +) -> anyhow::Result<( + matrix_sdk_rtc_livekit::livekit::webrtc::prelude::VideoResolution, + matrix_sdk_rtc_livekit::livekit::webrtc::video_source::native::NativeVideoSource, + V4l2CaptureMode, +)> { + use matrix_sdk_rtc_livekit::livekit::webrtc::prelude::VideoResolution; + use matrix_sdk_rtc_livekit::livekit::webrtc::video_source::native::NativeVideoSource; + + if matches!(config.source, V4l2VideoSource::TestRedFrames) { + let resolution = VideoResolution { + width: config.width.unwrap_or(640), + height: config.height.unwrap_or(480), + }; + let rtc_source = NativeVideoSource::new(resolution.clone(), true); + info!( + width = resolution.width, + height = resolution.height, + "configured generated red test video source" + ); + return Ok((resolution, rtc_source, V4l2CaptureMode::TestRedFrames)); + } + + use v4l::video::Capture; + use v4l::Device; + + let mut device = Device::with_path(&config.device).context("open V4L2 device")?; + let mut format = device.format().context("read V4L2 format")?; + + if let Some(width) = config.width { + format.width = width; + } + if let Some(height) = config.height { + format.height = height; + } + let format = set_format_with_fallback(&mut device, format)?; + let pixel_format = match &format.fourcc.repr { + b"NV12" => V4l2PixelFormat::Nv12, + b"YUYV" => V4l2PixelFormat::Yuyv, + _ => { + return Err(anyhow!( + "V4L2 device did not accept NV12 or YUYV; got {:?} instead", + format.fourcc + )); + } + }; + + let resolution = VideoResolution { width: format.width, height: format.height }; + info!( + device = %config.device, + width = format.width, + height = format.height, + fourcc = ?format.fourcc, + "configured V4L2 device format" + ); + let rtc_source = NativeVideoSource::new(resolution.clone(), true); + Ok((resolution, rtc_source, V4l2CaptureMode::Camera { device, pixel_format })) +} + +#[cfg(all(feature = "v4l2", target_os = "linux"))] +fn run_v4l2_capture_loop( + device: &mut v4l::Device, + resolution: matrix_sdk_rtc_livekit::livekit::webrtc::prelude::VideoResolution, + pixel_format: V4l2PixelFormat, + rtc_source: matrix_sdk_rtc_livekit::livekit::webrtc::video_source::native::NativeVideoSource, + stop_rx: std::sync::mpsc::Receiver<()>, +) -> anyhow::Result<()> { + use matrix_sdk_rtc_livekit::livekit::webrtc::native::yuv_helper; + use matrix_sdk_rtc_livekit::livekit::webrtc::prelude::{I420Buffer, VideoFrame, VideoRotation}; + use v4l::buffer::Type; + use v4l::io::mmap::Stream; + use v4l::io::traits::CaptureStream; + use v4l::video::Capture; + + let format = device.format().context("re-read V4L2 format")?; + let width = format.width as usize; + let height = format.height as usize; + let stride = if format.stride == 0 { + match pixel_format { + V4l2PixelFormat::Nv12 => width, + V4l2PixelFormat::Yuyv => width * 2, + } + } else { + format.stride as usize + }; + let expected_size = match pixel_format { + V4l2PixelFormat::Nv12 => stride * height + (stride * height / 2), + V4l2PixelFormat::Yuyv => stride * height, + }; + + let mut stream = + Stream::with_buffers(device, Type::VideoCapture, 4).context("start V4L2 stream")?; + let start = std::time::Instant::now(); + + let mut frame = VideoFrame { + rotation: VideoRotation::VideoRotation0, + buffer: I420Buffer::new(resolution.width, resolution.height), + timestamp_us: 0, + }; + + loop { + if stop_rx.try_recv().is_ok() { + break; + } + + let (data, _meta) = stream.next().context("read V4L2 frame")?; + if data.len() < expected_size { + warn!( + data_len = data.len(), + expected = expected_size, + "V4L2 frame shorter than expected" + ); + continue; + } + + let (stride_y, stride_u, stride_v) = frame.buffer.strides(); + let (dst_y, dst_u, dst_v) = frame.buffer.data_mut(); + + match pixel_format { + V4l2PixelFormat::Nv12 => { + let y_plane_len = stride * height; + let (src_y, src_uv) = data.split_at(y_plane_len); + + yuv_helper::nv12_to_i420( + src_y, + stride as u32, + src_uv, + stride as u32, + dst_y, + stride_y, + dst_u, + stride_u, + dst_v, + stride_v, + resolution.width as i32, + resolution.height as i32, + ); + } + V4l2PixelFormat::Yuyv => { + yuyv_to_i420( + data, width, stride, height, dst_y, stride_y, dst_u, stride_u, dst_v, stride_v, + ); + } + } + + frame.timestamp_us = start.elapsed().as_micros() as i64; + rtc_source.capture_frame(&frame); + } + + Ok(()) +} + +#[cfg(all(feature = "v4l2", target_os = "linux"))] +fn run_generated_red_capture_loop( + resolution: matrix_sdk_rtc_livekit::livekit::webrtc::prelude::VideoResolution, + rtc_source: matrix_sdk_rtc_livekit::livekit::webrtc::video_source::native::NativeVideoSource, + stop_rx: std::sync::mpsc::Receiver<()>, +) -> anyhow::Result<()> { + use matrix_sdk_rtc_livekit::livekit::webrtc::prelude::{I420Buffer, VideoFrame, VideoRotation}; + + let mut frame = VideoFrame { + rotation: VideoRotation::VideoRotation0, + buffer: I420Buffer::new(resolution.width, resolution.height), + timestamp_us: 0, + }; + let (stride_y, stride_u, stride_v) = frame.buffer.strides(); + let (dst_y, dst_u, dst_v) = frame.buffer.data_mut(); + + fill_plane(dst_y, stride_y as usize, resolution.width as usize, resolution.height as usize, 76); + fill_plane( + dst_u, + stride_u as usize, + (resolution.width / 2) as usize, + (resolution.height / 2) as usize, + 84, + ); + fill_plane( + dst_v, + stride_v as usize, + (resolution.width / 2) as usize, + (resolution.height / 2) as usize, + 255, + ); + + let frame_duration = std::time::Duration::from_millis(33); + let start = std::time::Instant::now(); + loop { + if stop_rx.try_recv().is_ok() { + break; + } + + frame.timestamp_us = start.elapsed().as_micros() as i64; + rtc_source.capture_frame(&frame); + std::thread::sleep(frame_duration); + } + + Ok(()) +} + +#[cfg(all(feature = "v4l2", target_os = "linux"))] +fn fill_plane(dst: &mut [u8], stride: usize, width: usize, height: usize, value: u8) { + for y in 0..height { + let row = &mut dst[y * stride..y * stride + width]; + row.fill(value); + } +} + +#[cfg(all(feature = "v4l2", target_os = "linux"))] +fn set_format_with_fallback( + device: &mut v4l::Device, + mut format: v4l::format::Format, +) -> anyhow::Result { + use v4l::video::Capture; + use v4l::FourCC; + + let nv12 = FourCC::new(b"NV12"); + let yuyv = FourCC::new(b"YUYV"); + + format.fourcc = nv12; + let format = device.set_format(&format).context("set V4L2 format")?; + if format.fourcc == nv12 { + return Ok(format); + } + + let mut format = format; + format.fourcc = yuyv; + let format = device.set_format(&format).context("set V4L2 format (YUYV)")?; + Ok(format) +} + +#[cfg(all(feature = "v4l2", target_os = "linux"))] +fn yuyv_to_i420( + src: &[u8], + width: usize, + src_stride: usize, + height: usize, + dst_y: &mut [u8], + dst_stride_y: u32, + dst_u: &mut [u8], + dst_stride_u: u32, + dst_v: &mut [u8], + dst_stride_v: u32, +) { + let dst_stride_y = dst_stride_y as usize; + let dst_stride_u = dst_stride_u as usize; + let dst_stride_v = dst_stride_v as usize; + + for y in 0..height { + let src_row = &src[y * src_stride..(y + 1) * src_stride]; + let dst_y_row = &mut dst_y[y * dst_stride_y..(y + 1) * dst_stride_y]; + for x in 0..width { + let pair = x & !1; + let base = pair * 2; + let y_offset = if x % 2 == 0 { 0 } else { 2 }; + dst_y_row[x] = src_row[base + y_offset]; + } + } + + let chroma_height = height / 2; + for y in 0..chroma_height { + let src_row0 = &src[(y * 2) * src_stride..(y * 2 + 1) * src_stride]; + let src_row1 = if y * 2 + 1 < height { + &src[(y * 2 + 1) * src_stride..(y * 2 + 2) * src_stride] + } else { + src_row0 + }; + let dst_u_row = &mut dst_u[y * dst_stride_u..(y + 1) * dst_stride_u]; + let dst_v_row = &mut dst_v[y * dst_stride_v..(y + 1) * dst_stride_v]; + + for x in 0..(width / 2) { + let base = x * 4; + let u0 = src_row0[base + 1] as u16; + let v0 = src_row0[base + 3] as u16; + let u1 = src_row1[base + 1] as u16; + let v1 = src_row1[base + 3] as u16; + dst_u_row[x] = ((u0 + u1) / 2) as u8; + dst_v_row[x] = ((v0 + v1) / 2) as u8; + } + } +} + +#[cfg(all(feature = "v4l2", target_os = "linux"))] +pub(crate) fn v4l2_config_from_env() -> anyhow::Result> { + let source = match optional_env("V4L2_VIDEO_SOURCE") + .as_deref() + .map(str::to_ascii_lowercase) + .as_deref() + { + Some("camera") | Some("webcam") | None => V4l2VideoSource::Camera, + Some("test_red") | Some("test-red") | Some("red") => V4l2VideoSource::TestRedFrames, + Some(other) => { + return Err(anyhow!( + "invalid V4L2_VIDEO_SOURCE '{other}'; expected camera|webcam|test_red|test-red|red" + )); + } + }; + + let device = if matches!(source, V4l2VideoSource::Camera) { + match optional_env("V4L2_DEVICE") { + Some(device) => device, + None => return Ok(None), + } + } else { + optional_env("V4L2_DEVICE").unwrap_or_else(|| "generated-test-source".to_owned()) + }; + + let width = optional_env("V4L2_WIDTH") + .as_deref() + .map(str::parse::) + .transpose() + .context("parse V4L2_WIDTH")?; + let height = optional_env("V4L2_HEIGHT") + .as_deref() + .map(str::parse::) + .transpose() + .context("parse V4L2_HEIGHT")?; + + Ok(Some(V4l2Config { device, width, height, source })) +} + +#[cfg(not(all(feature = "v4l2", target_os = "linux")))] +pub(crate) fn v4l2_config_from_env() -> anyhow::Result<()> { + Ok(()) +} From 699fe3278d858c591aec8893d0ffbb91b0193f6b Mon Sep 17 00:00:00 2001 From: herrfeder <14598229+herrfeder@users.noreply.github.com> Date: Mon, 11 May 2026 15:43:42 +0200 Subject: [PATCH 2/5] add additional info in readme --- Cargo.lock | 1814 ++++++++++++++++-- crates/matrix-sdk-rtc-livekit/Cargo.toml | 5 +- crates/matrix-sdk/Cargo.toml | 2 + crates/matrix-sdk/src/widget/capabilities.rs | 24 + crates/matrix-sdk/src/widget/element_call.rs | 1 + crates/matrix-sdk/src/widget/mod.rs | 8 +- examples/rtc_livekit_join/README.md | 3 + 7 files changed, 1662 insertions(+), 195 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 08900fbd978..ae707ecc7bb 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -11,7 +11,7 @@ dependencies = [ "macroific", "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -130,7 +130,7 @@ dependencies = [ "proc-macro-error2", "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -190,10 +190,10 @@ dependencies = [ "memchr", "proc-macro2", "quote", - "rustc-hash", + "rustc-hash 2.0.0", "serde", "serde_derive", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -236,6 +236,17 @@ version = "1.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5f093eed78becd229346bf859eec0aa4dd7ddde0757287b2b4107a1f09c80002" +[[package]] +name = "async-channel" +version = "1.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "81953c529336010edd6d8e358f886d9581267795c61b19475b71314bffa46d35" +dependencies = [ + "concurrent-queue", + "event-listener 2.5.3", + "futures-core", +] + [[package]] name = "async-channel" version = "2.5.0" @@ -273,6 +284,76 @@ dependencies = [ "tokio", ] +[[package]] +name = "async-executor" +version = "1.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c96bf972d85afc50bf5ab8fe2d54d1586b4e0b46c97c50a0c9e71e2f7bcd812a" +dependencies = [ + "async-task", + "concurrent-queue", + "fastrand", + "futures-lite", + "pin-project-lite", + "slab", +] + +[[package]] +name = "async-global-executor" +version = "2.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05b1b633a2115cd122d73b955eadd9916c18c8f510ec9cd1686404c60ad1c29c" +dependencies = [ + "async-channel 2.5.0", + "async-executor", + "async-io", + "async-lock", + "blocking", + "futures-lite", + "once_cell", +] + +[[package]] +name = "async-io" +version = "2.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "456b8a8feb6f42d237746d4b3e9a178494627745c3c56c6ea55d92ba50d026fc" +dependencies = [ + "autocfg", + "cfg-if", + "concurrent-queue", + "futures-io", + "futures-lite", + "parking", + "polling", + "rustix 1.0.8", + "slab", + "windows-sys 0.61.2", +] + +[[package]] +name = "async-lock" +version = "3.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "290f7f2596bd5b78a9fec8088ccd89180d7f9f55b94b0576823bbbdc72ee8311" +dependencies = [ + "event-listener 5.4.1", + "event-listener-strategy", + "pin-project-lite", +] + +[[package]] +name = "async-native-tls" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9343dc5acf07e79ff82d0c37899f079db3534d99f189a1837c8e549c99405bec" +dependencies = [ + "futures-util", + "native-tls", + "thiserror 1.0.63", + "url", +] + [[package]] name = "async-once-cell" version = "0.5.4" @@ -289,6 +370,32 @@ dependencies = [ "pin-project-lite", ] +[[package]] +name = "async-std" +version = "1.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c8e079a4ab67ae52b7403632e4618815d6db36d2a010cfe41b02c1b1578f93b" +dependencies = [ + "async-channel 1.9.0", + "async-global-executor", + "async-io", + "async-lock", + "crossbeam-utils", + "futures-channel", + "futures-core", + "futures-io", + "futures-lite", + "gloo-timers", + "kv-log-macro", + "log", + "memchr", + "once_cell", + "pin-project-lite", + "pin-utils", + "slab", + "wasm-bindgen-futures", +] + [[package]] name = "async-stream" version = "0.3.6" @@ -308,9 +415,15 @@ checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d" dependencies = [ "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", ] +[[package]] +name = "async-task" +version = "4.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de" + [[package]] name = "async-trait" version = "0.1.89" @@ -319,7 +432,22 @@ checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb" dependencies = [ "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", +] + +[[package]] +name = "async-tungstenite" +version = "0.25.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2cca750b12e02c389c1694d35c16539f88b8bbaa5945934fdc1b41a776688589" +dependencies = [ + "async-native-tls", + "async-std", + "futures-io", + "futures-util", + "log", + "pin-project-lite", + "tungstenite 0.21.0", ] [[package]] @@ -331,6 +459,19 @@ dependencies = [ "loom", ] +[[package]] +name = "asynchronous-codec" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a860072022177f903e59730004fb5dc13db9275b79bb2aef7ba8ce831956c233" +dependencies = [ + "bytes", + "futures-sink", + "futures-util", + "memchr", + "pin-project-lite", +] + [[package]] name = "atomic-waker" version = "1.1.2" @@ -375,7 +516,7 @@ dependencies = [ "bytes", "form_urlencoded", "futures-util", - "http", + "http 1.3.1", "http-body", "http-body-util", "hyper", @@ -407,7 +548,7 @@ checksum = "68464cd0412f486726fb3373129ef5d2993f90c34bc2bc1c1e9943b2f4fc7ca6" dependencies = [ "bytes", "futures-core", - "http", + "http 1.3.1", "http-body", "http-body-util", "mime", @@ -445,6 +586,12 @@ dependencies = [ "windows-link 0.2.1", ] +[[package]] +name = "base64" +version = "0.21.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567" + [[package]] name = "base64" version = "0.22.1" @@ -488,6 +635,35 @@ dependencies = [ "wiremock", ] +[[package]] +name = "bindgen" +version = "0.65.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfdf7b466f9a4903edc73f95d6d2bcd5baf8ae620638762244d3f60143643cc5" +dependencies = [ + "bitflags 1.3.2", + "cexpr", + "clang-sys", + "lazy_static", + "lazycell", + "log", + "peeking_take_while", + "prettyplease", + "proc-macro2", + "quote", + "regex", + "rustc-hash 1.1.0", + "shlex", + "syn 2.0.117", + "which", +] + +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + [[package]] name = "bitflags" version = "2.10.0" @@ -522,7 +698,7 @@ dependencies = [ "arrayvec", "cc", "cfg-if", - "constant_time_eq", + "constant_time_eq 0.3.1", ] [[package]] @@ -543,6 +719,29 @@ dependencies = [ "generic-array", ] +[[package]] +name = "blocking" +version = "1.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e83f8d02be6967315521be875afa792a316e28d57b5a2d401897e2a7921b7f21" +dependencies = [ + "async-channel 2.5.0", + "async-task", + "futures-io", + "futures-lite", + "piper", +] + +[[package]] +name = "bmrng" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d54df9073108f1558f90ae6c5bf5ab9c917c4185f5527b280c87a993cbead0ac" +dependencies = [ + "futures-core", + "tokio", +] + [[package]] name = "bon" version = "3.6.5" @@ -565,7 +764,7 @@ dependencies = [ "proc-macro2", "quote", "rustversion", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -613,6 +812,26 @@ version = "2.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "00f4369ba008f82b968b1acbe31715ec37bd45236fa0726605a36cc3060ea256" +[[package]] +name = "bzip2" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bdb116a6ef3f6c3698828873ad02c3014b3c85cadb88496095628e3ef1e347f8" +dependencies = [ + "bzip2-sys", + "libc", +] + +[[package]] +name = "bzip2-sys" +version = "0.1.13+1.0.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "225bff33b2141874fe80d71e07d6eec4f85c5c216453dd96388240f96e1acc14" +dependencies = [ + "cc", + "pkg-config", +] + [[package]] name = "camino" version = "1.2.2" @@ -699,6 +918,25 @@ version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c" +[[package]] +name = "cexpr" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766" +dependencies = [ + "nom", +] + +[[package]] +name = "cfg-expr" +version = "0.20.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3c6b04e07d8080154ed4ac03546d9a2b303cc2fe1901ba0b35b301516e289368" +dependencies = [ + "smallvec", + "target-lexicon", +] + [[package]] name = "cfg-if" version = "1.0.4" @@ -798,6 +1036,17 @@ dependencies = [ "zeroize", ] +[[package]] +name = "clang-sys" +version = "1.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4" +dependencies = [ + "glob", + "libc", + "libloading", +] + [[package]] name = "clap" version = "4.5.53" @@ -825,10 +1074,10 @@ version = "4.5.49" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2a0b5487afeab2deb2ff4e03a807ad1a03ac532ff5a2cee5d86884440c7f7671" dependencies = [ - "heck", + "heck 0.5.0", "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -846,6 +1095,17 @@ dependencies = [ "cc", ] +[[package]] +name = "codespan-reporting" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af491d569909a7e4dee0ad7db7f5341fef5c614d5b8ec8cf765732aba3cff681" +dependencies = [ + "serde", + "termcolor", + "unicode-width 0.2.0", +] + [[package]] name = "codspeed" version = "4.2.1" @@ -1014,12 +1274,28 @@ dependencies = [ "typewit", ] +[[package]] +name = "constant_time_eq" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc" + [[package]] name = "constant_time_eq" version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7c74b8349d32d297c9134b8c88677813a227df8f779daa29bfc29c183fe3dca6" +[[package]] +name = "core-foundation" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f" +dependencies = [ + "core-foundation-sys", + "libc", +] + [[package]] name = "core-foundation" version = "0.10.1" @@ -1101,6 +1377,15 @@ dependencies = [ "crossbeam-utils", ] +[[package]] +name = "crossbeam-queue" +version = "0.3.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f58bbc28f91df819d0aa2a2c00cd19754769c2fad90579b3592b1c9ba7a3115" +dependencies = [ + "crossbeam-utils", +] + [[package]] name = "crossbeam-utils" version = "0.8.20" @@ -1113,7 +1398,7 @@ version = "0.28.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "829d955a0bb380ef178a640b91779e3987da38c9aea133b20614cfed8cdea9c6" dependencies = [ - "bitflags", + "bitflags 2.10.0", "crossterm_winapi", "mio", "parking_lot", @@ -1156,7 +1441,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "32a2785755761f3ddc1492979ce1e48d2c00d09311c39e4466429188f3dd6501" dependencies = [ "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -1193,7 +1478,69 @@ checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3" dependencies = [ "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", +] + +[[package]] +name = "cxx" +version = "1.0.194" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "747d8437319e3a2f43d93b341c137927ca70c0f5dabeea7a005a73665e247c7e" +dependencies = [ + "cc", + "cxx-build", + "cxxbridge-cmd", + "cxxbridge-flags", + "cxxbridge-macro", + "foldhash 0.2.0", + "link-cplusplus", +] + +[[package]] +name = "cxx-build" +version = "1.0.194" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b0f4697d190a142477b16aef7da8a99bfdc41e7e8b1687583c0d23a79c7afc1e" +dependencies = [ + "cc", + "codespan-reporting", + "indexmap", + "proc-macro2", + "quote", + "scratch", + "syn 2.0.117", +] + +[[package]] +name = "cxxbridge-cmd" +version = "1.0.194" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d0956799fa8678d4c50eed028f2de1c0552ae183c76e976cf7ca8c4e36a7c328" +dependencies = [ + "clap", + "codespan-reporting", + "indexmap", + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "cxxbridge-flags" +version = "1.0.194" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23384a836ab4f0ad98ace7e3955ad2de39de42378ab487dc28d3990392cb283a" + +[[package]] +name = "cxxbridge-macro" +version = "1.0.194" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6acc6b5822b9526adfb4fc377b67128fdd60aac757cc4a741a6278603f763cf" +dependencies = [ + "indexmap", + "proc-macro2", + "quote", + "syn 2.0.117", ] [[package]] @@ -1227,7 +1574,7 @@ dependencies = [ "proc-macro2", "quote", "strsim", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -1241,7 +1588,7 @@ dependencies = [ "proc-macro2", "quote", "strsim", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -1252,7 +1599,7 @@ checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806" dependencies = [ "darling_core 0.20.10", "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -1263,9 +1610,28 @@ checksum = "2b5be8a7a562d315a5b92a630c30cec6bcf663e6673f00fbb69cca66a6f521b9" dependencies = [ "darling_core 0.21.1", "quote", - "syn 2.0.101", + "syn 2.0.117", ] +[[package]] +name = "dashmap" +version = "5.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856" +dependencies = [ + "cfg-if", + "hashbrown 0.14.5", + "lock_api", + "once_cell", + "parking_lot_core", +] + +[[package]] +name = "data-encoding" +version = "2.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4ae5f15dda3c708c0ade84bfee31ccab44a3da4f88015ed22f63732abe300c8" + [[package]] name = "date_header" version = "1.0.5" @@ -1346,7 +1712,7 @@ dependencies = [ "macroific", "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -1398,7 +1764,7 @@ dependencies = [ "darling 0.20.10", "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -1408,7 +1774,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ab63b0e2bf4d5928aff72e83a7dace85d7bba5fe12dcc3c5a572d78caffd3f3c" dependencies = [ "derive_builder_core", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -1437,7 +1803,7 @@ checksum = "cb7330aeadfbe296029522e6c40f315320aba36fc43a5b3632f3795348f3bd22" dependencies = [ "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -1448,7 +1814,7 @@ checksum = "bda628edc44c4bb645fbe0f758797143e4e07926f7ebf4e9bdfbd3d2ce621df3" dependencies = [ "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", "unicode-xid", ] @@ -1498,7 +1864,7 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" dependencies = [ "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -1560,6 +1926,15 @@ version = "0.3.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f" +[[package]] +name = "encoding_rs" +version = "0.8.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3" +dependencies = [ + "cfg-if", +] + [[package]] name = "equivalent" version = "1.0.1" @@ -1576,6 +1951,12 @@ dependencies = [ "windows-sys 0.60.2", ] +[[package]] +name = "event-listener" +version = "2.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0" + [[package]] name = "event-listener" version = "5.4.1" @@ -1593,7 +1974,7 @@ version = "0.5.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93" dependencies = [ - "event-listener", + "event-listener 5.4.1", "pin-project-lite", ] @@ -1753,6 +2134,38 @@ dependencies = [ "url", ] +[[package]] +name = "example-rtc-livekit-join" +version = "0.1.0" +dependencies = [ + "anyhow", + "async-trait", + "axum", + "base64 0.22.1", + "futures-util", + "jpeg-decoder", + "matrix-sdk", + "matrix-sdk-base", + "matrix-sdk-crypto", + "matrix-sdk-rtc-livekit", + "mime", + "once_cell", + "pulldown-cmark 0.9.6", + "rand 0.8.5", + "reqwest 0.13.2", + "ruma", + "serde", + "serde_json", + "sha2", + "tokio", + "tracing", + "tracing-subscriber", + "url", + "uuid", + "v4l", + "zeromq", +] + [[package]] name = "example-secret-storage" version = "0.1.0" @@ -1787,7 +2200,7 @@ checksum = "dd65f1b59dd22d680c7a626cc4a000c1e03d241c51c3e034d2bc9f1e90734f9b" dependencies = [ "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -1861,7 +2274,7 @@ dependencies = [ "macroific", "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -1900,6 +2313,12 @@ dependencies = [ "winapi", ] +[[package]] +name = "fixedbitset" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80" + [[package]] name = "flate2" version = "1.1.5" @@ -1922,6 +2341,27 @@ version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" +[[package]] +name = "foldhash" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb" + +[[package]] +name = "foreign-types" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1" +dependencies = [ + "foreign-types-shared", +] + +[[package]] +name = "foreign-types-shared" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b" + [[package]] name = "form_urlencoded" version = "1.2.2" @@ -1940,6 +2380,16 @@ dependencies = [ "autocfg", ] +[[package]] +name = "fs2" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9564fc758e15025b46aa6643b1b77d047d1a56a1aea6e01002ac0c7026876213" +dependencies = [ + "libc", + "winapi", +] + [[package]] name = "fs4" version = "0.13.1" @@ -2004,6 +2454,19 @@ version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6" +[[package]] +name = "futures-lite" +version = "2.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad" +dependencies = [ + "fastrand", + "futures-core", + "futures-io", + "parking", + "pin-project-lite", +] + [[package]] name = "futures-macro" version = "0.3.31" @@ -2012,7 +2475,7 @@ checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650" dependencies = [ "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -2078,6 +2541,15 @@ dependencies = [ "version_check", ] +[[package]] +name = "getopts" +version = "0.2.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfe4fbac503b8d1f88e6676011885f34b7174f46e59956bba534ba83abded4df" +dependencies = [ + "unicode-width 0.2.0", +] + [[package]] name = "getrandom" version = "0.2.15" @@ -2127,6 +2599,63 @@ version = "0.32.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7" +[[package]] +name = "gio-sys" +version = "0.21.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0071fe88dba8e40086c8ff9bbb62622999f49628344b1d1bf490a48a29d80f22" +dependencies = [ + "glib-sys", + "gobject-sys", + "libc", + "system-deps", + "windows-sys 0.61.2", +] + +[[package]] +name = "glib" +version = "0.21.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "16de123c2e6c90ce3b573b7330de19be649080ec612033d397d72da265f1bd8b" +dependencies = [ + "bitflags 2.10.0", + "futures-channel", + "futures-core", + "futures-executor", + "futures-task", + "futures-util", + "gio-sys", + "glib-macros", + "glib-sys", + "gobject-sys", + "libc", + "memchr", + "smallvec", +] + +[[package]] +name = "glib-macros" +version = "0.21.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf59b675301228a696fe01c3073974643365080a76cc3ed5bc2cbc466ad87f17" +dependencies = [ + "heck 0.5.0", + "proc-macro-crate", + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "glib-sys" +version = "0.21.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2d95e1a3a19ae464a7286e14af9a90683c64d70c02532d88d87ce95056af3e6c" +dependencies = [ + "libc", + "system-deps", +] + [[package]] name = "glob" version = "0.3.3" @@ -2158,6 +2687,17 @@ dependencies = [ "web-sys", ] +[[package]] +name = "gobject-sys" +version = "0.21.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2dca35da0d19a18f4575f3cb99fe1c9e029a2941af5662f326f738a21edaf294" +dependencies = [ + "glib-sys", + "libc", + "system-deps", +] + [[package]] name = "goblin" version = "0.8.2" @@ -2203,7 +2743,7 @@ dependencies = [ "fnv", "futures-core", "futures-sink", - "http", + "http 1.3.1", "indexmap", "slab", "tokio", @@ -2237,7 +2777,7 @@ version = "0.15.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289" dependencies = [ - "foldhash", + "foldhash 0.1.5", ] [[package]] @@ -2261,10 +2801,10 @@ version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b3314d5adb5d94bcdf56771f2e50dbbc80bb4bdf88967526706205ac9eff24eb" dependencies = [ - "base64", + "base64 0.22.1", "bytes", "headers-core", - "http", + "http 1.3.1", "httpdate", "mime", "sha1", @@ -2276,9 +2816,15 @@ version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "54b4a22553d4242c49fddb9ba998a99962b5cc6f22cb5a3482bec22522403ce4" dependencies = [ - "http", + "http 1.3.1", ] +[[package]] +name = "heck" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8" + [[package]] name = "heck" version = "0.5.0" @@ -2321,6 +2867,15 @@ dependencies = [ "digest", ] +[[package]] +name = "home" +version = "0.5.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc627f471c528ff0c4a49e1d5e60450c8f6461dd6d10ba9dcd3a61d3dff7728d" +dependencies = [ + "windows-sys 0.61.2", +] + [[package]] name = "hostname" version = "0.4.1" @@ -2348,6 +2903,17 @@ version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e9025058dae765dee5070ec375f591e2ba14638c63feff74f13805a72e523163" +[[package]] +name = "http" +version = "0.2.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1" +dependencies = [ + "bytes", + "fnv", + "itoa", +] + [[package]] name = "http" version = "1.3.1" @@ -2375,7 +2941,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184" dependencies = [ "bytes", - "http", + "http 1.3.1", ] [[package]] @@ -2386,7 +2952,7 @@ checksum = "793429d76616a256bcb62c2a2ec2bed781c8307e797e2598c50010f2bee2544f" dependencies = [ "bytes", "futures-util", - "http", + "http 1.3.1", "http-body", "pin-project-lite", ] @@ -2414,7 +2980,7 @@ dependencies = [ "futures-channel", "futures-core", "h2", - "http", + "http 1.3.1", "http-body", "httparse", "httpdate", @@ -2433,13 +2999,30 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5ee4be2c948921a1a5320b629c4193916ed787a7f7f293fd3f7f5a6c9de74155" dependencies = [ "futures-util", - "http", + "http 1.3.1", "hyper", "hyper-util", - "rustls", + "rustls 0.23.38", + "rustls-native-certs 0.7.3", "rustls-pki-types", "tokio", - "tokio-rustls", + "tokio-rustls 0.26.0", + "tower-service", +] + +[[package]] +name = "hyper-tls" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "70206fc6890eaca9fde8a0bf71caa2ddfc9fe045ac9e5c70df101a7dbde866e0" +dependencies = [ + "bytes", + "http-body-util", + "hyper", + "hyper-util", + "native-tls", + "tokio", + "tokio-native-tls", "tower-service", ] @@ -2449,12 +3032,12 @@ version = "0.1.16" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8d9b05277c7e8da2c93a568989bb6207bef0112e8d17df7a6eda4a3cf143bc5e" dependencies = [ - "base64", + "base64 0.22.1", "bytes", "futures-channel", "futures-core", "futures-util", - "http", + "http 1.3.1", "http-body", "hyper", "ipnet", @@ -2462,9 +3045,11 @@ dependencies = [ "percent-encoding", "pin-project-lite", "socket2 0.6.0", + "system-configuration", "tokio", "tower-service", "tracing", + "windows-registry", ] [[package]] @@ -2614,7 +3199,7 @@ checksum = "1ec89e9337638ecdc08744df490b221a7399bf8d164eb52a665454e60e075ad6" dependencies = [ "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -2694,7 +3279,7 @@ checksum = "0ab604ee7085efba6efc65e4ebca0e9533e3aff6cb501d7d77b211e3a781c6d5" dependencies = [ "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -2777,7 +3362,7 @@ dependencies = [ "indoc", "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -2816,6 +3401,15 @@ dependencies = [ "either", ] +[[package]] +name = "itertools" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1c173a5686ce8bfa551b3563d0c2170bf24ca44da99c7ca4bfdab5418c3fe57" +dependencies = [ + "either", +] + [[package]] name = "itertools" version = "0.13.0" @@ -2871,6 +3465,15 @@ dependencies = [ "libc", ] +[[package]] +name = "jpeg-decoder" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00810f1d8b74be64b13dbf3db89ac67740615d6c891f0e7b6179326533011a07" +dependencies = [ + "rayon", +] + [[package]] name = "js-sys" version = "0.3.91" @@ -2910,6 +3513,19 @@ dependencies = [ "serde_json", ] +[[package]] +name = "jsonwebtoken" +version = "9.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a87cc7a48537badeae96744432de36f4be2b4a34a05a5ef32e9dd8a1c169dde" +dependencies = [ + "base64 0.22.1", + "js-sys", + "ring", + "serde", + "serde_json", +] + [[package]] name = "jvm-getter" version = "0.1.0" @@ -2932,6 +3548,15 @@ dependencies = [ "typewit", ] +[[package]] +name = "kv-log-macro" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0de8b303297635ad57c9f5059fd9cee7a47f8e8daa09df0fcd07dd39fb22977f" +dependencies = [ + "log", +] + [[package]] name = "language-tags" version = "0.3.2" @@ -2947,6 +3572,12 @@ version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" +[[package]] +name = "lazycell" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55" + [[package]] name = "leb128fmt" version = "0.1.0" @@ -2965,6 +3596,16 @@ version = "0.2.175" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6a82ae493e598baaea5209805c49bbf2ea7de956d50d7da0da1164f9c6d28543" +[[package]] +name = "libloading" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55" +dependencies = [ + "cfg-if", + "windows-link 0.2.1", +] + [[package]] name = "libm" version = "0.2.15" @@ -2977,7 +3618,7 @@ version = "0.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d" dependencies = [ - "bitflags", + "bitflags 2.10.0", "libc", ] @@ -2992,6 +3633,39 @@ dependencies = [ "vcpkg", ] +[[package]] +name = "libwebrtc" +version = "0.3.26" +source = "git+https://github.com/onestacked/livekit-rust-sdks?branch=EC-compat-changes#f4085eb1b814e90d85cb02152433a1d3951625f1" +dependencies = [ + "cxx", + "glib", + "jni", + "js-sys", + "lazy_static", + "livekit-protocol", + "livekit-runtime", + "log", + "parking_lot", + "serde", + "serde_json", + "thiserror 1.0.63", + "tokio", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", + "webrtc-sys", +] + +[[package]] +name = "link-cplusplus" +version = "1.0.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f78c730aaa7d0b9336a299029ea49f9ee53b0ed06e9202e8cb7db9bae7b8c82" +dependencies = [ + "cc", +] + [[package]] name = "linux-raw-sys" version = "0.4.14" @@ -3010,6 +3684,89 @@ version = "0.7.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4ee93343901ab17bd981295f2cf0026d4ad018c7c31ba84549a4ddbb47a45104" +[[package]] +name = "livekit" +version = "0.7.32" +source = "git+https://github.com/onestacked/livekit-rust-sdks?branch=EC-compat-changes#f4085eb1b814e90d85cb02152433a1d3951625f1" +dependencies = [ + "base64 0.22.1", + "bmrng", + "bytes", + "chrono", + "futures-util", + "hkdf", + "lazy_static", + "libloading", + "libwebrtc", + "livekit-api", + "livekit-protocol", + "livekit-runtime", + "log", + "parking_lot", + "prost 0.12.6", + "semver", + "serde", + "serde_json", + "sha2", + "thiserror 1.0.63", + "tokio", +] + +[[package]] +name = "livekit-api" +version = "0.4.14" +source = "git+https://github.com/onestacked/livekit-rust-sdks?branch=EC-compat-changes#f4085eb1b814e90d85cb02152433a1d3951625f1" +dependencies = [ + "async-tungstenite", + "base64 0.21.7", + "futures-util", + "http 1.3.1", + "jsonwebtoken", + "livekit-protocol", + "livekit-runtime", + "log", + "parking_lot", + "pbjson-types", + "prost 0.12.6", + "rand 0.9.2", + "reqwest 0.12.28", + "rustls-native-certs 0.6.3", + "scopeguard", + "serde", + "serde_json", + "sha2", + "thiserror 1.0.63", + "tokio", + "tokio-rustls 0.24.1", + "tokio-tungstenite", + "url", +] + +[[package]] +name = "livekit-protocol" +version = "0.7.1" +source = "git+https://github.com/onestacked/livekit-rust-sdks?branch=EC-compat-changes#f4085eb1b814e90d85cb02152433a1d3951625f1" +dependencies = [ + "futures-util", + "livekit-runtime", + "parking_lot", + "pbjson", + "pbjson-types", + "prost 0.12.6", + "serde", + "thiserror 1.0.63", + "tokio", +] + +[[package]] +name = "livekit-runtime" +version = "0.4.0" +source = "git+https://github.com/onestacked/livekit-rust-sdks?branch=EC-compat-changes#f4085eb1b814e90d85cb02152433a1d3951625f1" +dependencies = [ + "tokio", + "tokio-stream", +] + [[package]] name = "lock_api" version = "0.4.12" @@ -3025,6 +3782,9 @@ name = "log" version = "0.4.27" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94" +dependencies = [ + "value-bag", +] [[package]] name = "log-panics" @@ -3090,7 +3850,7 @@ dependencies = [ "proc-macro2", "quote", "sealed", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -3102,7 +3862,7 @@ dependencies = [ "proc-macro2", "quote", "sealed", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -3115,7 +3875,7 @@ dependencies = [ "macroific_core", "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -3170,7 +3930,7 @@ dependencies = [ "proc-macro-error2", "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -3184,7 +3944,7 @@ dependencies = [ "assert-json-diff", "assert_matches", "assert_matches2", - "async-channel", + "async-channel 2.5.0", "async-once-cell", "async-stream", "async-trait", @@ -3195,7 +3955,7 @@ dependencies = [ "cfg-if", "ctor", "dirs", - "event-listener", + "event-listener 5.4.1", "eyeball", "eyeball-im", "eyre", @@ -3203,7 +3963,7 @@ dependencies = [ "futures-executor", "futures-util", "gloo-timers", - "http", + "http 1.3.1", "imbl", "indexmap", "insta", @@ -3226,10 +3986,10 @@ dependencies = [ "pin-project-lite", "proptest", "rand 0.10.1", - "reqwest", + "reqwest 0.13.2", "ruma", - "rustls", - "rustls-native-certs", + "rustls 0.23.38", + "rustls-native-certs 0.8.3", "rustls-pki-types", "serde", "serde_html_form", @@ -3268,7 +4028,7 @@ dependencies = [ "assert_matches2", "assign", "async-trait", - "bitflags", + "bitflags 2.10.0", "decancer", "eyeball", "eyeball-im", @@ -3277,7 +4037,7 @@ dependencies = [ "getrandom 0.3.4", "gloo-timers", "growable-bloom-filter", - "http", + "http 1.3.1", "matrix-sdk-common", "matrix-sdk-crypto", "matrix-sdk-store-encryption", @@ -3352,7 +4112,7 @@ dependencies = [ "futures-util", "hkdf", "hmac", - "http", + "http 1.3.1", "insta", "itertools 0.14.0", "js_option", @@ -3360,7 +4120,7 @@ dependencies = [ "matrix-sdk-qrcode", "matrix-sdk-test", "matrix-sdk-test-utils", - "pbkdf2", + "pbkdf2 0.12.2", "proptest", "rand 0.10.1", "rmp-serde", @@ -3391,13 +4151,13 @@ dependencies = [ "assert_matches2", "futures-util", "hmac", - "http", + "http 1.3.1", "js_int", "matrix-sdk-common", "matrix-sdk-crypto", "matrix-sdk-ffi-macros", "matrix-sdk-sqlite", - "pbkdf2", + "pbkdf2 0.12.2", "rand 0.10.1", "ruma", "serde", @@ -3465,7 +4225,7 @@ version = "0.7.0" dependencies = [ "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -3475,7 +4235,7 @@ dependencies = [ "assert_matches", "assert_matches2", "async-trait", - "base64", + "base64 0.22.1", "futures-util", "getrandom 0.4.2", "gloo-timers", @@ -3520,7 +4280,7 @@ dependencies = [ "futures", "futures-core", "futures-util", - "http", + "http 1.3.1", "json-structural-diff", "matrix-sdk", "matrix-sdk-base", @@ -3529,7 +4289,7 @@ dependencies = [ "matrix-sdk-test-utils", "matrix-sdk-ui", "rand 0.10.1", - "reqwest", + "reqwest 0.13.2", "serde_json", "similar-asserts", "stream_assert", @@ -3551,6 +4311,28 @@ dependencies = [ "vodozemac", ] +[[package]] +name = "matrix-sdk-rtc-livekit" +version = "0.16.0" +dependencies = [ + "async-trait", + "base64 0.22.1", + "futures-util", + "livekit", + "matrix-sdk", + "matrix-sdk-base", + "matrix-sdk-crypto", + "rand 0.8.5", + "reqwest 0.12.28", + "ruma", + "serde", + "serde_json", + "thiserror 2.0.18", + "tokio", + "tracing", + "url", +] + [[package]] name = "matrix-sdk-search" version = "0.16.0" @@ -3561,7 +4343,7 @@ dependencies = [ "hkdf", "hmac", "matrix-sdk-test", - "pbkdf2", + "pbkdf2 0.12.2", "rand 0.10.1", "ruma", "sha2", @@ -3610,13 +4392,13 @@ name = "matrix-sdk-store-encryption" version = "0.16.0" dependencies = [ "anyhow", - "base64", + "base64 0.22.1", "blake3", "chacha20poly1305", "getrandom 0.2.15", "getrandom 0.4.2", "hmac", - "pbkdf2", + "pbkdf2 0.12.2", "rand 0.10.1", "rmp-serde", "serde", @@ -3633,7 +4415,7 @@ dependencies = [ "as_variant", "ctor", "getrandom 0.4.2", - "http", + "http 1.3.1", "insta", "matrix-sdk-common", "matrix-sdk-test-macros", @@ -3653,7 +4435,7 @@ name = "matrix-sdk-test-macros" version = "0.16.0" dependencies = [ "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -3676,7 +4458,7 @@ dependencies = [ "async-rx", "async-stream", "async_cell", - "bitflags", + "bitflags 2.10.0", "chrono", "emojis", "eyeball", @@ -3749,7 +4531,7 @@ dependencies = [ "macroific", "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -3763,9 +4545,9 @@ dependencies = [ [[package]] name = "memchr" -version = "2.7.4" +version = "2.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" +checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79" [[package]] name = "memmap2" @@ -3837,6 +4619,12 @@ dependencies = [ "pxfm", ] +[[package]] +name = "multimap" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d87ecb2933e8aeadb3e3a02b828fed80a7528047e68b4f424523a0981a3a084" + [[package]] name = "multiverse" version = "0.1.0" @@ -3873,6 +4661,23 @@ version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2195bf6aa996a481483b29d62a7663eed3fe39600c460e323f8ff41e90bdd89b" +[[package]] +name = "native-tls" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6cdede44f9a69cab2899a2049e2c3bd49bf911a157f6a3353d4a91c61abbce44" +dependencies = [ + "libc", + "log", + "openssl", + "openssl-probe 0.1.6", + "openssl-sys", + "schannel", + "security-framework 2.11.1", + "security-framework-sys", + "tempfile", +] + [[package]] name = "ndk-sys" version = "0.5.0+25.2.9519653" @@ -3894,7 +4699,7 @@ version = "0.30.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "74523f3a35e05aba87a1d978330aef40f67b0304ac79c1c00b294c9830543db6" dependencies = [ - "bitflags", + "bitflags 2.10.0", "cfg-if", "cfg_aliases", "libc", @@ -3960,10 +4765,10 @@ version = "5.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "51e219e79014df21a225b1860a479e2dcd7cbd9130f4defd4bd0e191ea31d67d" dependencies = [ - "base64", + "base64 0.22.1", "chrono", "getrandom 0.2.15", - "http", + "http 1.3.1", "rand 0.8.5", "serde", "serde_json", @@ -3980,7 +4785,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "234fb5c965bbce983ee5de636a7a51d6a3223da8067ea02f9ab2d2d78ac08be2" dependencies = [ "oauth2", - "reqwest", + "reqwest 0.13.2", ] [[package]] @@ -4016,12 +4821,55 @@ version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381" +[[package]] +name = "openssl" +version = "0.10.79" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf0b434746ee2832f4f0baf10137e1cabb18cbe6912c69e2e33263c45250f542" +dependencies = [ + "bitflags 2.10.0", + "cfg-if", + "foreign-types", + "libc", + "openssl-macros", + "openssl-sys", +] + +[[package]] +name = "openssl-macros" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "openssl-probe" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e" + [[package]] name = "openssl-probe" version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9f50d9b3dabb09ecd771ad0aa242ca6894994c130308ca3d7684634df8037391" +[[package]] +name = "openssl-sys" +version = "0.9.115" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "158fe5b292746440aa6e7a7e690e55aeb72d41505e2804c23c6973ad0e9c9781" +dependencies = [ + "cc", + "libc", + "pkg-config", + "vcpkg", +] + [[package]] name = "option-ext" version = "0.2.0" @@ -4097,12 +4945,72 @@ dependencies = [ "windows-targets 0.52.6", ] +[[package]] +name = "password-hash" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7676374caaee8a325c9e7a2ae557f216c5563a171d6997b0ef8a65af35147700" +dependencies = [ + "base64ct", + "rand_core 0.6.4", + "subtle", +] + [[package]] name = "paste" version = "1.0.15" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a" +[[package]] +name = "pbjson" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1030c719b0ec2a2d25a5df729d6cff1acf3cc230bf766f4f97833591f7577b90" +dependencies = [ + "base64 0.21.7", + "serde", +] + +[[package]] +name = "pbjson-build" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2580e33f2292d34be285c5bc3dba5259542b083cfad6037b6d70345f24dcb735" +dependencies = [ + "heck 0.4.1", + "itertools 0.11.0", + "prost 0.12.6", + "prost-types", +] + +[[package]] +name = "pbjson-types" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "18f596653ba4ac51bdecbb4ef6773bc7f56042dc13927910de1684ad3d32aa12" +dependencies = [ + "bytes", + "chrono", + "pbjson", + "pbjson-build", + "prost 0.12.6", + "prost-build", + "serde", +] + +[[package]] +name = "pbkdf2" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "83a0692ec44e4cf1ef28ca317f14f8f07da2d95ec3fa01f86e4467b725e60917" +dependencies = [ + "digest", + "hmac", + "password-hash", + "sha2", +] + [[package]] name = "pbkdf2" version = "0.12.2" @@ -4112,6 +5020,12 @@ dependencies = [ "digest", ] +[[package]] +name = "peeking_take_while" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19b17cddbe7ec3f8bc800887bab5e717348c95ea2ca0b1bf0837fb964dc67099" + [[package]] name = "percent-encoding" version = "2.3.2" @@ -4149,7 +5063,7 @@ dependencies = [ "pest_meta", "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -4163,6 +5077,16 @@ dependencies = [ "sha2", ] +[[package]] +name = "petgraph" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db" +dependencies = [ + "fixedbitset", + "indexmap", +] + [[package]] name = "phf" version = "0.13.1" @@ -4214,6 +5138,17 @@ version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" +[[package]] +name = "piper" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c835479a4443ded371d6c535cbfd8d31ad92c5d23ae9770a61bc155e4992a3c1" +dependencies = [ + "atomic-waker", + "fastrand", + "futures-io", +] + [[package]] name = "pkcs8" version = "0.10.2" @@ -4264,6 +5199,20 @@ dependencies = [ "plotters-backend", ] +[[package]] +name = "polling" +version = "3.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218" +dependencies = [ + "cfg-if", + "concurrent-queue", + "hermit-abi 0.5.2", + "pin-project-lite", + "rustix 1.0.8", + "windows-sys 0.61.2", +] + [[package]] name = "poly1305" version = "0.8.0" @@ -4300,14 +5249,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6837b9e10d61f45f987d50808f83d1ee3d206c66acf650c3e4ae2e1f6ddedf55" dependencies = [ "proc-macro2", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] name = "proc-macro-crate" -version = "3.2.0" +version = "3.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8ecf48c7ca261d60b74ab1a7b20da18bede46776b2e55535cb958eb595c5fa7b" +checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f" dependencies = [ "toml_edit", ] @@ -4348,7 +5297,7 @@ version = "1.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bee689443a2bd0a16ab0348b52ee43e3b2d1b1f931c8aa5c9f8de4c86fbe8c40" dependencies = [ - "bitflags", + "bitflags 2.10.0", "num-traits", "rand 0.9.2", "rand_chacha 0.9.0", @@ -4357,6 +5306,16 @@ dependencies = [ "unarray", ] +[[package]] +name = "prost" +version = "0.12.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "deb1435c188b76130da55f17a466d252ff7b1418b2ad3e037d127b94e3411f29" +dependencies = [ + "bytes", + "prost-derive 0.12.6", +] + [[package]] name = "prost" version = "0.14.3" @@ -4364,7 +5323,41 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d2ea70524a2f82d518bce41317d0fae74151505651af45faf1ffbd6fd33f0568" dependencies = [ "bytes", - "prost-derive", + "prost-derive 0.14.3", +] + +[[package]] +name = "prost-build" +version = "0.12.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22505a5c94da8e3b7c2996394d1c933236c4d743e81a410bcca4e6989fc066a4" +dependencies = [ + "bytes", + "heck 0.5.0", + "itertools 0.10.5", + "log", + "multimap", + "once_cell", + "petgraph", + "prettyplease", + "prost 0.12.6", + "prost-types", + "regex", + "syn 2.0.117", + "tempfile", +] + +[[package]] +name = "prost-derive" +version = "0.12.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "81bddcdb20abf9501610992b6759a4c888aef7d1a7247ef75e2404275ac24af1" +dependencies = [ + "anyhow", + "itertools 0.10.5", + "proc-macro2", + "quote", + "syn 2.0.117", ] [[package]] @@ -4377,7 +5370,28 @@ dependencies = [ "itertools 0.14.0", "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", +] + +[[package]] +name = "prost-types" +version = "0.12.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9091c90b0a32608e984ff2fa4091273cbdd755d54935c51d520887f4a1dbd5b0" +dependencies = [ + "prost 0.12.6", +] + +[[package]] +name = "pulldown-cmark" +version = "0.9.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57206b407293d2bcd3af849ce869d52068623f19e1b5ff8e8778e3309439682b" +dependencies = [ + "bitflags 2.10.0", + "getopts", + "memchr", + "unicase", ] [[package]] @@ -4386,7 +5400,7 @@ version = "0.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1e8bbe1a966bd2f362681a44f6edce3c2310ac21e4d5067a6e7ec396297a6ea0" dependencies = [ - "bitflags", + "bitflags 2.10.0", "memchr", "pulldown-cmark-escape", "unicase", @@ -4427,8 +5441,8 @@ dependencies = [ "pin-project-lite", "quinn-proto", "quinn-udp", - "rustc-hash", - "rustls", + "rustc-hash 2.0.0", + "rustls 0.23.38", "socket2 0.6.0", "thiserror 2.0.18", "tokio", @@ -4448,8 +5462,8 @@ dependencies = [ "lru-slab", "rand 0.9.2", "ring", - "rustc-hash", - "rustls", + "rustc-hash 2.0.0", + "rustls 0.23.38", "rustls-pki-types", "slab", "thiserror 2.0.18", @@ -4602,7 +5616,7 @@ version = "0.29.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "eabd94c2f37801c20583fc49dd5cd6b0ba68c716787c2dd6ed18571e1e63117b" dependencies = [ - "bitflags", + "bitflags 2.10.0", "cassowary", "compact_str", "crossterm", @@ -4658,7 +5672,7 @@ version = "0.5.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2a908a6e00f1fdd0dfd9c0eb08ce85126f6d8bbda50017e74bc4a4b7d4a926a4" dependencies = [ - "bitflags", + "bitflags 2.10.0", ] [[package]] @@ -4701,37 +5715,86 @@ version = "0.8.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c" +[[package]] +name = "reqwest" +version = "0.12.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eddd3ca559203180a307f12d114c268abf583f59b03cb906fd0b3ff8646c1147" +dependencies = [ + "base64 0.22.1", + "bytes", + "encoding_rs", + "futures-channel", + "futures-core", + "futures-util", + "h2", + "http 1.3.1", + "http-body", + "http-body-util", + "hyper", + "hyper-rustls", + "hyper-tls", + "hyper-util", + "js-sys", + "log", + "mime", + "native-tls", + "percent-encoding", + "pin-project-lite", + "quinn", + "rustls 0.23.38", + "rustls-native-certs 0.8.3", + "rustls-pki-types", + "serde", + "serde_json", + "serde_urlencoded", + "sync_wrapper", + "tokio", + "tokio-native-tls", + "tokio-rustls 0.26.0", + "tower", + "tower-http", + "tower-service", + "url", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", +] + [[package]] name = "reqwest" version = "0.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ab3f43e3283ab1488b624b44b0e988d0acea0b3214e694730a055cb6b2efa801" dependencies = [ - "base64", + "base64 0.22.1", "bytes", "futures-channel", "futures-core", "futures-util", "h2", - "http", + "http 1.3.1", "http-body", "http-body-util", "hyper", "hyper-rustls", + "hyper-tls", "hyper-util", "js-sys", "log", + "native-tls", "percent-encoding", "pin-project-lite", "quinn", - "rustls", + "rustls 0.23.38", "rustls-pki-types", "rustls-platform-verifier", "serde", "serde_json", "sync_wrapper", "tokio", - "tokio-rustls", + "tokio-native-tls", + "tokio-rustls 0.26.0", "tokio-util", "tower", "tower-http", @@ -4828,7 +5891,7 @@ dependencies = [ "as_variant", "assign", "bytes", - "http", + "http 1.3.1", "js_int", "js_option", "maplit", @@ -4849,12 +5912,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b69b11cb6ccf0e27c3c44c50e2e4799337921c66d4e6a490c084f18c5b4481ec" dependencies = [ "as_variant", - "base64", + "base64 0.22.1", "bytes", "date_header", "form_urlencoded", "getrandom 0.4.2", - "http", + "http 1.3.1", "indexmap", "js_int", "konst", @@ -4887,7 +5950,7 @@ dependencies = [ "js_int", "js_option", "language-tags", - "pulldown-cmark", + "pulldown-cmark 0.13.0", "ruma-common", "ruma-html", "ruma-macros", @@ -4907,7 +5970,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "06ebea8616d3d3cc26057f7856b9ef42aba1e37c44d2c136856134f3083a44ef" dependencies = [ "headers", - "http", + "http 1.3.1", "http-auth", "httparse", "js_int", @@ -4957,7 +6020,7 @@ dependencies = [ "quote", "ruma-identifiers-validation", "serde", - "syn 2.0.101", + "syn 2.0.117", "toml 1.1.2+spec-1.1.0", ] @@ -4967,7 +6030,7 @@ version = "0.20.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "134d4b6b5b039d3f52b3a28516f348c718ab5f0785fed1328588636c9c67b54c" dependencies = [ - "base64", + "base64 0.22.1", "ed25519-dalek", "pkcs8", "rand 0.10.1", @@ -4983,7 +6046,7 @@ version = "0.37.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "165ca6e57b20e1351573e3729b958bc62f0e48025386970b6e4d29e7a7e71f3f" dependencies = [ - "bitflags", + "bitflags 2.10.0", "fallible-iterator", "fallible-streaming-iterator", "hashlink", @@ -5007,6 +6070,12 @@ version = "0.1.24" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f" +[[package]] +name = "rustc-hash" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" + [[package]] name = "rustc-hash" version = "2.0.0" @@ -5028,7 +6097,7 @@ version = "0.38.41" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d7f649912bc1495e167a6edee79151c84b1bad49748cb4f1f1167f459f6224f6" dependencies = [ - "bitflags", + "bitflags 2.10.0", "errno", "libc", "linux-raw-sys 0.4.14", @@ -5041,26 +6110,64 @@ version = "1.0.8" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "11181fbabf243db407ef8df94a6ce0b2f9a733bd8be4ad02b4eda9602296cac8" dependencies = [ - "bitflags", + "bitflags 2.10.0", "errno", "libc", "linux-raw-sys 0.9.4", "windows-sys 0.60.2", ] +[[package]] +name = "rustls" +version = "0.21.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e" +dependencies = [ + "log", + "ring", + "rustls-webpki 0.101.7", + "sct", +] + [[package]] name = "rustls" version = "0.23.38" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "69f9466fb2c14ea04357e91413efb882e2a6d4a406e625449bc0a5d360d53a21" +checksum = "69f9466fb2c14ea04357e91413efb882e2a6d4a406e625449bc0a5d360d53a21" +dependencies = [ + "aws-lc-rs", + "log", + "once_cell", + "ring", + "rustls-pki-types", + "rustls-webpki 0.103.13", + "subtle", + "zeroize", +] + +[[package]] +name = "rustls-native-certs" +version = "0.6.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a9aace74cb666635c918e9c12bc0d348266037aa8eb599b5cba565709a8dff00" +dependencies = [ + "openssl-probe 0.1.6", + "rustls-pemfile 1.0.4", + "schannel", + "security-framework 2.11.1", +] + +[[package]] +name = "rustls-native-certs" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5bfb394eeed242e909609f56089eecfe5fda225042e8b171791b9c95f5931e5" dependencies = [ - "aws-lc-rs", - "log", - "once_cell", + "openssl-probe 0.1.6", + "rustls-pemfile 2.2.0", "rustls-pki-types", - "rustls-webpki", - "subtle", - "zeroize", + "schannel", + "security-framework 2.11.1", ] [[package]] @@ -5069,10 +6176,28 @@ version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "612460d5f7bea540c490b2b6395d8e34a953e52b491accd6c86c8164c5932a63" dependencies = [ - "openssl-probe", + "openssl-probe 0.2.0", "rustls-pki-types", "schannel", - "security-framework", + "security-framework 3.5.1", +] + +[[package]] +name = "rustls-pemfile" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c" +dependencies = [ + "base64 0.21.7", +] + +[[package]] +name = "rustls-pemfile" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dce314e5fee3f39953d46bb63bb8a46d40c2f8fb7cc5a3b6cab2bde9721d6e50" +dependencies = [ + "rustls-pki-types", ] [[package]] @@ -5091,16 +6216,16 @@ version = "0.6.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1d99feebc72bae7ab76ba994bb5e121b8d83d910ca40b36e0921f53becc41784" dependencies = [ - "core-foundation", + "core-foundation 0.10.1", "core-foundation-sys", "jni", "log", "once_cell", - "rustls", - "rustls-native-certs", + "rustls 0.23.38", + "rustls-native-certs 0.8.3", "rustls-platform-verifier-android", - "rustls-webpki", - "security-framework", + "rustls-webpki 0.103.13", + "security-framework 3.5.1", "security-framework-sys", "webpki-root-certs", "windows-sys 0.61.2", @@ -5112,6 +6237,16 @@ version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f" +[[package]] +name = "rustls-webpki" +version = "0.101.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765" +dependencies = [ + "ring", + "untrusted", +] + [[package]] name = "rustls-webpki" version = "0.103.13" @@ -5166,6 +6301,12 @@ version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" +[[package]] +name = "scratch" +version = "1.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d68f2ec51b097e4c1a75b681a8bec621909b5e91f15bb7b840c4f2f7b01148b2" + [[package]] name = "scroll" version = "0.12.0" @@ -5183,7 +6324,17 @@ checksum = "7f81c2fde025af7e69b1d1420531c8a8811ca898919db177141a85313b1cb932" dependencies = [ "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", +] + +[[package]] +name = "sct" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414" +dependencies = [ + "ring", + "untrusted", ] [[package]] @@ -5194,7 +6345,20 @@ checksum = "22f968c5ea23d555e670b449c1c5e7b2fc399fdaec1d304a17cd48e288abc107" dependencies = [ "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", +] + +[[package]] +name = "security-framework" +version = "2.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02" +dependencies = [ + "bitflags 2.10.0", + "core-foundation 0.9.4", + "core-foundation-sys", + "libc", + "security-framework-sys", ] [[package]] @@ -5203,8 +6367,8 @@ version = "3.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b3297343eaf830f66ede390ea39da1d462b6b0c1b000f420d0a83f898bbbe6ef" dependencies = [ - "bitflags", - "core-foundation", + "bitflags 2.10.0", + "core-foundation 0.10.1", "core-foundation-sys", "libc", "security-framework-sys", @@ -5238,7 +6402,7 @@ checksum = "eb25f439f97d26fea01d717fa626167ceffcd981addaa670001e70505b72acbb" dependencies = [ "cfg_aliases", "httpdate", - "reqwest", + "reqwest 0.13.2", "sentry-backtrace", "sentry-contexts", "sentry-core", @@ -5312,7 +6476,7 @@ version = "0.47.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "27701acc51e68db5281802b709010395bfcbcb128b1d0a4e5873680d3b47ff0c" dependencies = [ - "bitflags", + "bitflags 2.10.0", "sentry-backtrace", "sentry-core", "tracing-core", @@ -5384,7 +6548,7 @@ checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" dependencies = [ "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -5569,9 +6733,9 @@ dependencies = [ [[package]] name = "smallvec" -version = "1.13.2" +version = "1.15.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67" +checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" dependencies = [ "serde", ] @@ -5697,11 +6861,11 @@ version = "0.26.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4c6bee85a5a24955dc440386795aa378cd9cf82acd5f764469152d2270e581be" dependencies = [ - "heck", + "heck 0.5.0", "proc-macro2", "quote", "rustversion", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -5710,11 +6874,11 @@ version = "0.27.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c77a8c5abcaf0f9ce05d62342b7d298c346515365c36b673df4ebe3ced01fde8" dependencies = [ - "heck", + "heck 0.5.0", "proc-macro2", "quote", "rustversion", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -5736,9 +6900,9 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.101" +version = "2.0.117" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8ce2b7fc941b3a24138a0a7cf8e858bfc6a992e7978a068a5c760deb0ed43caf" +checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" dependencies = [ "proc-macro2", "quote", @@ -5762,7 +6926,41 @@ checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971" dependencies = [ "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", +] + +[[package]] +name = "system-configuration" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3c879d448e9d986b661742763247d3693ed13609438cf3d006f51f5368a5ba6b" +dependencies = [ + "bitflags 2.10.0", + "core-foundation 0.9.4", + "system-configuration-sys", +] + +[[package]] +name = "system-configuration-sys" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e1d1b10ced5ca923a1fcb8d03e96b8d3268065d724548c0211415ff6ac6bac4" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "system-deps" +version = "7.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "48c8f33736f986f16d69b6cb8b03f55ddcad5c41acc4ccc39dd88e84aa805e7f" +dependencies = [ + "cfg-expr", + "heck 0.5.0", + "pkg-config", + "toml 0.9.7", + "version-compare", ] [[package]] @@ -5773,7 +6971,7 @@ checksum = "502915c7381c5cb2d2781503962610cb880ad8f1a0ca95df1bae645d5ebf2545" dependencies = [ "aho-corasick", "arc-swap", - "base64", + "base64 0.22.1", "bitpacking", "bon", "byteorder", @@ -5798,7 +6996,7 @@ dependencies = [ "rayon", "regex", "rust-stemmers", - "rustc-hash", + "rustc-hash 2.0.0", "serde", "serde_json", "sketches-ddsketch", @@ -5888,7 +7086,7 @@ dependencies = [ "tantivy-bitpacker", "tantivy-common", "tantivy-fst", - "zstd", + "zstd 0.13.3", ] [[package]] @@ -5911,6 +7109,12 @@ dependencies = [ "serde", ] +[[package]] +name = "target-lexicon" +version = "0.13.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df7f62577c25e07834649fc3b39fafdc597c0a3527dc1c60129201ccfcbaa50c" + [[package]] name = "tempfile" version = "3.23.0" @@ -5934,6 +7138,15 @@ dependencies = [ "utf-8", ] +[[package]] +name = "termcolor" +version = "1.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755" +dependencies = [ + "winapi-util", +] + [[package]] name = "textwrap" version = "0.16.2" @@ -5971,7 +7184,7 @@ checksum = "a4558b58466b9ad7ca0f102865eccc95938dca1a74a856f2b57b6629050da261" dependencies = [ "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -5982,7 +7195,7 @@ checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5" dependencies = [ "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -6081,7 +7294,9 @@ dependencies = [ "bytes", "libc", "mio", + "parking_lot", "pin-project-lite", + "signal-hook-registry", "socket2 0.6.0", "tokio-macros", "windows-sys 0.61.2", @@ -6095,7 +7310,27 @@ checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5" dependencies = [ "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", +] + +[[package]] +name = "tokio-native-tls" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2" +dependencies = [ + "native-tls", + "tokio", +] + +[[package]] +name = "tokio-rustls" +version = "0.24.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081" +dependencies = [ + "rustls 0.21.12", + "tokio", ] [[package]] @@ -6104,7 +7339,7 @@ version = "0.26.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0c7bc40d0e5a97695bb96e27995cd3a08538541b0a846f65bba7a359f36700d4" dependencies = [ - "rustls", + "rustls 0.23.38", "rustls-pki-types", "tokio", ] @@ -6134,6 +7369,23 @@ dependencies = [ "tokio-stream", ] +[[package]] +name = "tokio-tungstenite" +version = "0.20.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "212d5dcb2a1ce06d81107c3d0ffa3121fe974b73f068c8282cb1c32328113b6c" +dependencies = [ + "futures-util", + "log", + "native-tls", + "rustls 0.21.12", + "rustls-native-certs 0.6.3", + "tokio", + "tokio-native-tls", + "tokio-rustls 0.24.1", + "tungstenite 0.20.1", +] + [[package]] name = "tokio-util" version = "0.7.17" @@ -6142,6 +7394,7 @@ checksum = "2efa149fe76073d6e8fd97ef4f4eca7b67f599660115591483572e406e165594" dependencies = [ "bytes", "futures-core", + "futures-io", "futures-sink", "pin-project-lite", "tokio", @@ -6175,12 +7428,6 @@ dependencies = [ "winnow 1.0.1", ] -[[package]] -name = "toml_datetime" -version = "0.6.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0dd7358ecb8fc2f8d014bf86f6f638ce72ba252a2c3a2572f2a795f1d23efb41" - [[package]] name = "toml_datetime" version = "0.7.2" @@ -6201,13 +7448,14 @@ dependencies = [ [[package]] name = "toml_edit" -version = "0.22.22" +version = "0.25.6+spec-1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4ae48d6208a266e853d946088ed816055e556cc6028c5e8e2b84d9fa5dd7c7f5" +checksum = "0db3bae107c9522f86d361697dee1d7386a2ddcf659d5aea5159819a21a3c4a7" dependencies = [ "indexmap", - "toml_datetime 0.6.8", - "winnow 0.6.20", + "toml_datetime 1.1.1+spec-1.1.0", + "toml_parser", + "winnow 1.0.1", ] [[package]] @@ -6248,11 +7496,11 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8" dependencies = [ "async-compression", - "bitflags", + "bitflags 2.10.0", "bytes", "futures-core", "futures-util", - "http", + "http 1.3.1", "http-body", "http-body-util", "iri-string", @@ -6305,7 +7553,7 @@ source = "git+https://github.com/tokio-rs/tracing.git?rev=20f5b3d8ba057ca9c4ae00 dependencies = [ "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -6366,7 +7614,7 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "743912880bcd21d1034063a1b5c6630d444d5a6cc9f90e2c0a200bbe278907c7" dependencies = [ - "bitflags", + "bitflags 2.10.0", "crossterm", "derive_builder", "itertools 0.14.0", @@ -6395,6 +7643,47 @@ dependencies = [ "ratatui", ] +[[package]] +name = "tungstenite" +version = "0.20.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e3dac10fd62eaf6617d3a904ae222845979aec67c615d1c842b4002c7666fb9" +dependencies = [ + "byteorder", + "bytes", + "data-encoding", + "http 0.2.12", + "httparse", + "log", + "native-tls", + "rand 0.8.5", + "rustls 0.21.12", + "sha1", + "thiserror 1.0.63", + "url", + "utf-8", +] + +[[package]] +name = "tungstenite" +version = "0.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ef1a641ea34f399a848dea702823bbecfb4c486f911735368f1f137cb8257e1" +dependencies = [ + "byteorder", + "bytes", + "data-encoding", + "http 1.3.1", + "httparse", + "log", + "native-tls", + "rand 0.8.5", + "sha1", + "thiserror 1.0.63", + "url", + "utf-8", +] + [[package]] name = "typenum" version = "1.17.0" @@ -6540,7 +7829,7 @@ dependencies = [ "fs-err", "glob", "goblin 0.8.2", - "heck", + "heck 0.5.0", "indexmap", "once_cell", "serde", @@ -6587,7 +7876,7 @@ dependencies = [ "indexmap", "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -6602,7 +7891,7 @@ dependencies = [ "proc-macro2", "quote", "serde", - "syn 2.0.101", + "syn 2.0.117", "toml 0.9.7", "uniffi_meta", ] @@ -6626,7 +7915,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a806dddc8208f22efd7e95a5cdf88ed43d0f3271e8f63b47e757a8bbdb43b63a" dependencies = [ "anyhow", - "heck", + "heck 0.5.0", "indexmap", "tempfile", "uniffi_internal_macros", @@ -6714,12 +8003,38 @@ dependencies = [ "wasm-bindgen", ] +[[package]] +name = "v4l" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8fbfea44a46799d62c55323f3c55d06df722fbe577851d848d328a1041c3403" +dependencies = [ + "bitflags 1.3.2", + "libc", + "v4l2-sys-mit", +] + +[[package]] +name = "v4l2-sys-mit" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6779878362b9bacadc7893eac76abe69612e8837ef746573c4a5239daf11990b" +dependencies = [ + "bindgen", +] + [[package]] name = "valuable" version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d" +[[package]] +name = "value-bag" +version = "1.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ba6f5989077681266825251a52748b8c1d8a4ad098cc37e440103d0ea717fc0" + [[package]] name = "vcpkg" version = "0.2.15" @@ -6764,6 +8079,12 @@ dependencies = [ "rustversion", ] +[[package]] +name = "version-compare" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03c2856837ef78f57382f06b2b8563a2f512f7185d732608fd9176cb3b8edf0e" + [[package]] name = "version_check" version = "0.9.4" @@ -6778,7 +8099,7 @@ checksum = "b98bf83c0992966775b8012f194b07b44928996163e5a05b741b43891571ae5b" dependencies = [ "aes", "arrayvec", - "base64", + "base64 0.22.1", "base64ct", "cbc", "chacha20poly1305", @@ -6788,7 +8109,7 @@ dependencies = [ "hkdf", "hmac", "matrix-pickle", - "prost", + "prost 0.14.3", "rand 0.8.5", "serde", "serde_bytes", @@ -6889,7 +8210,7 @@ dependencies = [ "bumpalo", "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", "wasm-bindgen-shared", ] @@ -6932,7 +8253,7 @@ checksum = "67008cdde4769831958536b0f11b3bdd0380bde882be17fff9c2f34bb4549abd" dependencies = [ "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -7000,7 +8321,7 @@ version = "0.244.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe" dependencies = [ - "bitflags", + "bitflags 2.10.0", "hashbrown 0.15.2", "indexmap", "semver", @@ -7057,6 +8378,34 @@ dependencies = [ "rustls-pki-types", ] +[[package]] +name = "webrtc-sys" +version = "0.3.23" +source = "git+https://github.com/onestacked/livekit-rust-sdks?branch=EC-compat-changes#f4085eb1b814e90d85cb02152433a1d3951625f1" +dependencies = [ + "cc", + "cxx", + "cxx-build", + "glob", + "log", + "pkg-config", + "webrtc-sys-build", +] + +[[package]] +name = "webrtc-sys-build" +version = "0.3.13" +source = "git+https://github.com/onestacked/livekit-rust-sdks?branch=EC-compat-changes#f4085eb1b814e90d85cb02152433a1d3951625f1" +dependencies = [ + "anyhow", + "fs2", + "regex", + "reqwest 0.12.28", + "scratch", + "semver", + "zip", +] + [[package]] name = "weedle2" version = "5.0.0" @@ -7066,6 +8415,18 @@ dependencies = [ "nom", ] +[[package]] +name = "which" +version = "4.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "87ba24419a2078cd2b0f2ede2691b6c66d8e47836da3b6db8265ebad47afbfc7" +dependencies = [ + "either", + "home", + "once_cell", + "rustix 0.38.41", +] + [[package]] name = "wildmatch" version = "2.6.1" @@ -7166,7 +8527,7 @@ checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836" dependencies = [ "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -7177,7 +8538,7 @@ checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8" dependencies = [ "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -7202,6 +8563,17 @@ dependencies = [ "windows-link 0.1.1", ] +[[package]] +name = "windows-registry" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b3bab093bdd303a1240bb99b8aba8ea8a69ee19d34c9e2ef9594e708a4878820" +dependencies = [ + "windows-link 0.1.1", + "windows-result", + "windows-strings", +] + [[package]] name = "windows-result" version = "0.3.4" @@ -7526,15 +8898,6 @@ version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650" -[[package]] -name = "winnow" -version = "0.6.20" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "36c1fec1a2bb5866f07c25f68c26e565c4c200aebb96d7e55710c19d3e8ac49b" -dependencies = [ - "memchr", -] - [[package]] name = "winnow" version = "0.7.13" @@ -7549,6 +8912,9 @@ name = "winnow" version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "09dac053f1cd375980747450bfc7250c264eaae0583872e845c0c7cd578872b5" +dependencies = [ + "memchr", +] [[package]] name = "wiremock" @@ -7557,10 +8923,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "08db1edfb05d9b3c1542e521aea074442088292f00b5f28e435c714a98f85031" dependencies = [ "assert-json-diff", - "base64", + "base64 0.22.1", "deadpool 0.12.3", "futures", - "http", + "http 1.3.1", "http-body-util", "hyper", "hyper-util", @@ -7589,7 +8955,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc" dependencies = [ "anyhow", - "heck", + "heck 0.5.0", "wit-parser", ] @@ -7600,10 +8966,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21" dependencies = [ "anyhow", - "heck", + "heck 0.5.0", "indexmap", "prettyplease", - "syn 2.0.101", + "syn 2.0.117", "wasm-metadata", "wit-bindgen-core", "wit-component", @@ -7619,7 +8985,7 @@ dependencies = [ "prettyplease", "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", "wit-bindgen-core", "wit-bindgen-rust", ] @@ -7631,7 +8997,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2" dependencies = [ "anyhow", - "bitflags", + "bitflags 2.10.0", "indexmap", "log", "serde", @@ -7744,7 +9110,7 @@ checksum = "2380878cad4ac9aac1e2435f3eb4020e8374b5f13c296cb75b4620ff8e229154" dependencies = [ "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", "synstructure", ] @@ -7765,7 +9131,7 @@ checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e" dependencies = [ "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", ] [[package]] @@ -7785,7 +9151,7 @@ checksum = "595eed982f7d355beb85837f651fa22e90b3c044842dc7f2c2842c086f295808" dependencies = [ "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", "synstructure", ] @@ -7806,7 +9172,34 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69" dependencies = [ "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", +] + +[[package]] +name = "zeromq" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a4528179201f6eecf211961a7d3276faa61554c82651ecc66387f68fc3004bd" +dependencies = [ + "async-trait", + "asynchronous-codec", + "bytes", + "crossbeam-queue", + "dashmap", + "futures-channel", + "futures-io", + "futures-task", + "futures-util", + "log", + "num-traits", + "once_cell", + "parking_lot", + "rand 0.8.5", + "regex", + "thiserror 1.0.63", + "tokio", + "tokio-util", + "uuid", ] [[package]] @@ -7828,7 +9221,36 @@ checksum = "6eafa6dfb17584ea3e2bd6e76e0cc15ad7af12b09abdd1ca55961bed9b1063c6" dependencies = [ "proc-macro2", "quote", - "syn 2.0.101", + "syn 2.0.117", +] + +[[package]] +name = "zip" +version = "0.6.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "760394e246e4c28189f19d488c058bf16f564016aefac5d32bb1f3b51d5e9261" +dependencies = [ + "aes", + "byteorder", + "bzip2", + "constant_time_eq 0.1.5", + "crc32fast", + "crossbeam-utils", + "flate2", + "hmac", + "pbkdf2 0.11.0", + "sha1", + "time", + "zstd 0.11.2+zstd.1.5.2", +] + +[[package]] +name = "zstd" +version = "0.11.2+zstd.1.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "20cc960326ece64f010d2d2107537f26dc589a6573a316bd5b1dba685fa5fde4" +dependencies = [ + "zstd-safe 5.0.2+zstd.1.5.2", ] [[package]] @@ -7837,7 +9259,17 @@ version = "0.13.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a" dependencies = [ - "zstd-safe", + "zstd-safe 7.2.4", +] + +[[package]] +name = "zstd-safe" +version = "5.0.2+zstd.1.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d2a5585e04f9eea4b2a3d1eca508c4dee9592a89ef6f450c11719da0726f4db" +dependencies = [ + "libc", + "zstd-sys", ] [[package]] diff --git a/crates/matrix-sdk-rtc-livekit/Cargo.toml b/crates/matrix-sdk-rtc-livekit/Cargo.toml index 32c41b99fec..47ceb2a2013 100644 --- a/crates/matrix-sdk-rtc-livekit/Cargo.toml +++ b/crates/matrix-sdk-rtc-livekit/Cargo.toml @@ -13,7 +13,6 @@ rustdoc-args = ["--generate-link-to-definition"] [features] default = ["rustls-tls"] - rustls-tls = ["matrix-sdk/rustls-tls", "livekit/rustls-tls-native-roots"] native-tls = ["matrix-sdk/native-tls", "livekit/native-tls"] js = ["matrix-sdk/js"] @@ -26,11 +25,11 @@ livekit = { git = "https://github.com/onestacked/livekit-rust-sdks", branch = "E matrix-sdk = { workspace = true, features = ["e2e-encryption", "experimental-send-custom-to-device"] } matrix-sdk-base.workspace = true matrix-sdk-crypto.workspace = true -rand.workspace = true +rand = { version = "0.8.5", features = ["std", "std_rng"] } ruma.workspace = true serde = { workspace = true, features = ["derive"] } serde_json.workspace = true -reqwest.workspace = true +reqwest = { version = "0.12", features = ["json", "native-tls"] } futures-util.workspace = true thiserror.workspace = true tokio.workspace = true diff --git a/crates/matrix-sdk/Cargo.toml b/crates/matrix-sdk/Cargo.toml index ab0764b87c5..7038506e15a 100644 --- a/crates/matrix-sdk/Cargo.toml +++ b/crates/matrix-sdk/Cargo.toml @@ -72,6 +72,8 @@ experimental-push-secrets = [ ] markdown = ["ruma/markdown"] +native-tls = ["reqwest/native-tls"] +rustls-tls = ["reqwest/native-tls"] socks = ["reqwest/socks"] local-server = ["dep:axum", "dep:rand", "dep:tower"] sso-login = ["local-server"] diff --git a/crates/matrix-sdk/src/widget/capabilities.rs b/crates/matrix-sdk/src/widget/capabilities.rs index 26f30b70562..2c4d2c9a9f2 100644 --- a/crates/matrix-sdk/src/widget/capabilities.rs +++ b/crates/matrix-sdk/src/widget/capabilities.rs @@ -39,6 +39,30 @@ pub trait CapabilitiesProvider: SendOutsideWasm + SyncOutsideWasm + 'static { ) -> impl Future + SendOutsideWasm; } +/// A [`CapabilitiesProvider`] that always returns a static capability set. +#[derive(Clone, Debug)] +pub struct StaticCapabilitiesProvider { + capabilities: Capabilities, +} + +impl StaticCapabilitiesProvider { + /// Create a new static capabilities provider. + pub fn new(capabilities: Capabilities) -> Self { + Self { capabilities } + } + + /// Get the configured capabilities. + pub fn capabilities(&self) -> &Capabilities { + &self.capabilities + } +} + +impl CapabilitiesProvider for StaticCapabilitiesProvider { + async fn acquire_capabilities(&self, _capabilities: Capabilities) -> Capabilities { + self.capabilities.clone() + } +} + /// Capabilities that a widget can request from a client. #[derive(Clone, Debug, Default)] #[cfg_attr(test, derive(PartialEq))] diff --git a/crates/matrix-sdk/src/widget/element_call.rs b/crates/matrix-sdk/src/widget/element_call.rs index 5a71399b71a..3829b195af0 100644 --- a/crates/matrix-sdk/src/widget/element_call.rs +++ b/crates/matrix-sdk/src/widget/element_call.rs @@ -334,6 +334,7 @@ pub fn element_call_capabilities(own_user_id: &UserId, own_device_id: &DeviceId) requires_client: true, update_delayed_event: true, send_delayed_event: true, + download_file: false, } } diff --git a/crates/matrix-sdk/src/widget/mod.rs b/crates/matrix-sdk/src/widget/mod.rs index 8331d916b1e..fa75d529fe4 100644 --- a/crates/matrix-sdk/src/widget/mod.rs +++ b/crates/matrix-sdk/src/widget/mod.rs @@ -36,13 +36,19 @@ use self::{ use crate::{Result, room::Room, widget::machine::DownloadFileResponse}; mod capabilities; +mod element_call; mod filter; mod machine; mod matrix; mod settings; pub use self::{ - capabilities::{Capabilities, CapabilitiesProvider}, + capabilities::{Capabilities, CapabilitiesProvider, StaticCapabilitiesProvider}, + element_call::{ + element_call_capabilities, element_call_member_content, element_call_send_event_message, + publish_call_membership_via_widget, send_hangup_via_widget, start_element_call_widget, + ElementCallWidget, ElementCallWidgetOptions, + }, filter::{Filter, MessageLikeEventFilter, StateEventFilter, ToDeviceEventFilter}, settings::{ ClientProperties, EncryptionSystem, Intent, VirtualElementCallWidgetConfig, diff --git a/examples/rtc_livekit_join/README.md b/examples/rtc_livekit_join/README.md index 5785c5f4922..7e820f8b8e0 100644 --- a/examples/rtc_livekit_join/README.md +++ b/examples/rtc_livekit_join/README.md @@ -41,12 +41,15 @@ ELEMENT_CALL_URL=https://webclient.matrix.example.org ### Optional Variables for Connection ```bash +MATRIX_DEVICE_ID="iABCdef" MATRIX_RECOVERY_KEY="recov ery key client exam ple" LIVEKIT_TOKEN=your-token \ LIVEKIT_SFU_GET_URL=https://demo.call.bundesmessenger.info/sfu/get \ LIVEKIT_SERVICE_URL=wss://livekit.example.org \ ``` +When defining static `MATRIX_DEVICE_ID` it is necessary to use the local crypto store (needs to compile sqlite feature). Otherwise the Device ID needs to be changed for every run because the same Device ID won't work twice. (It's a feature, not a bug) + ### Optional Variables for Video Feeding ```bash From 0fb28232dc4c92cf0ff9259f9bbe3fc3d5e669a7 Mon Sep 17 00:00:00 2001 From: herrfeder <14598229+herrfeder@users.noreply.github.com> Date: Mon, 11 May 2026 20:39:20 +0200 Subject: [PATCH 3/5] reduce intermediate build notes from earlier stages Signed-off-by: herrfeder <14598229+herrfeder@users.noreply.github.com> --- Cargo.lock | 2206 +++++++++++----------- crates/matrix-sdk-rtc-livekit/Cargo.toml | 1 + crates/matrix-sdk-rtc-livekit/README.md | 39 - examples/rtc_livekit_join/README.md | 2 +- 4 files changed, 1157 insertions(+), 1091 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index ae707ecc7bb..755499d7490 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -47,35 +47,23 @@ checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0" dependencies = [ "cfg-if", "cipher", - "cpufeatures 0.2.12", -] - -[[package]] -name = "ahash" -version = "0.8.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011" -dependencies = [ - "cfg-if", - "once_cell", - "version_check", - "zerocopy", + "cpufeatures 0.2.17", ] [[package]] name = "aho-corasick" -version = "1.1.3" +version = "1.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916" +checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301" dependencies = [ "memchr", ] [[package]] name = "allocator-api2" -version = "0.2.18" +version = "0.2.21" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c6cb57a04249c6480766f7f7cef5467412af1490f8d1e243141daddada3264f" +checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923" [[package]] name = "android_system_properties" @@ -94,15 +82,15 @@ checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299" [[package]] name = "anstyle" -version = "1.0.11" +version = "1.0.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "862ed96ca487e809f1c8e5a8447f6ee2cf102f846893800b20cebdf541fc6bbd" +checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000" [[package]] name = "anyhow" -version = "1.0.100" +version = "1.0.102" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61" +checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c" [[package]] name = "anymap2" @@ -135,21 +123,24 @@ dependencies = [ [[package]] name = "arc-swap" -version = "1.7.1" +version = "1.9.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "69f7f8c3906b62b754cd5326047894316021dcfe5a194c8ea52bdd94934a3457" +checksum = "6a3a1fd6f75306b68087b831f025c712524bcb19aad54e557b1129cfa0a2b207" +dependencies = [ + "rustversion", +] [[package]] name = "archery" -version = "1.2.1" +version = "1.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eae2ed21cd55021f05707a807a5fc85695dafb98832921f6cfa06db67ca5b869" +checksum = "70e0a5f99dfebb87bb342d0f53bb92c81842e100bbb915223e38349580e5441d" [[package]] name = "arrayref" -version = "0.3.8" +version = "0.3.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9d151e35f61089500b617991b791fc8bfd237ae50cd5950803758a179b41e67a" +checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb" [[package]] name = "arrayvec" @@ -190,7 +181,7 @@ dependencies = [ "memchr", "proc-macro2", "quote", - "rustc-hash 2.0.0", + "rustc-hash 2.1.2", "serde", "serde_derive", "syn 2.0.117", @@ -205,7 +196,7 @@ dependencies = [ "memchr", "serde", "serde_derive", - "winnow 0.7.13", + "winnow 0.7.15", ] [[package]] @@ -273,13 +264,12 @@ dependencies = [ [[package]] name = "async-compression" -version = "0.4.12" +version = "0.4.42" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fec134f64e2bc57411226dfc4e52dec859ddfc7e711fc5e07b612584f000e4aa" +checksum = "e79b3f8a79cccc2898f31920fc69f304859b3bd567490f75ebf51ae1c792a9ac" dependencies = [ - "flate2", - "futures-core", - "memchr", + "compression-codecs", + "compression-core", "pin-project-lite", "tokio", ] @@ -326,7 +316,7 @@ dependencies = [ "futures-lite", "parking", "polling", - "rustix 1.0.8", + "rustix 1.1.4", "slab", "windows-sys 0.61.2", ] @@ -350,7 +340,7 @@ checksum = "9343dc5acf07e79ff82d0c37899f079db3534d99f189a1837c8e549c99405bec" dependencies = [ "futures-util", "native-tls", - "thiserror 1.0.63", + "thiserror 1.0.69", "url", ] @@ -362,9 +352,9 @@ checksum = "4288f83726785267c6f2ef073a3d83dc3f9b81464e9f99898240cced85fce35a" [[package]] name = "async-rx" -version = "0.2.0" +version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9053bf9b3852b83be29d9a29dd7dcf68273f81b10d55ae8beceedb4d23f41448" +checksum = "a82c1a761cd7b772912fd2500f2c0a850c0c72f5f66543038393ac6cfaa3659a" dependencies = [ "futures-core", "pin-project-lite", @@ -480,15 +470,15 @@ checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0" [[package]] name = "autocfg" -version = "1.3.0" +version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0" +checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8" [[package]] name = "aws-lc-rs" -version = "1.16.2" +version = "1.16.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a054912289d18629dc78375ba2c3726a3afe3ff71b4edba9dedfca0e3446d1fc" +checksum = "0ec6fb3fe69024a75fa7e1bfb48aa6cf59706a101658ea01bfd33b2b248a038f" dependencies = [ "aws-lc-sys", "zeroize", @@ -496,9 +486,9 @@ dependencies = [ [[package]] name = "aws-lc-sys" -version = "0.39.0" +version = "0.40.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1fa7e52a4c5c547c741610a2c6f123f3881e409b714cd27e6798ef020c514f0a" +checksum = "f50037ee5e1e41e7b8f9d161680a725bd1626cb6f8c7e901f91f942850852fe7" dependencies = [ "cc", "cmake", @@ -508,15 +498,15 @@ dependencies = [ [[package]] name = "axum" -version = "0.8.4" +version = "0.8.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "021e862c184ae977658b36c4500f7feac3221ca5da43e3f25bd04ab6c79a29b5" +checksum = "31b698c5f9a010f6573133b09e0de5408834d0c82f8d7475a89fc1867a71cd90" dependencies = [ "axum-core", "bytes", "form_urlencoded", "futures-util", - "http 1.3.1", + "http 1.4.0", "http-body", "http-body-util", "hyper", @@ -527,8 +517,7 @@ dependencies = [ "mime", "percent-encoding", "pin-project-lite", - "rustversion", - "serde", + "serde_core", "serde_json", "serde_path_to_error", "serde_urlencoded", @@ -542,18 +531,17 @@ dependencies = [ [[package]] name = "axum-core" -version = "0.5.2" +version = "0.5.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "68464cd0412f486726fb3373129ef5d2993f90c34bc2bc1c1e9943b2f4fc7ca6" +checksum = "08c78f31d7b1291f7ee735c1c6780ccde7785daae9a9206026862dab7d8792d1" dependencies = [ "bytes", "futures-core", - "http 1.3.1", + "http 1.4.0", "http-body", "http-body-util", "mime", "pin-project-lite", - "rustversion", "sync_wrapper", "tower-layer", "tower-service", @@ -583,7 +571,7 @@ dependencies = [ "miniz_oxide", "object", "rustc-demangle", - "windows-link 0.2.1", + "windows-link", ] [[package]] @@ -606,9 +594,9 @@ checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06" [[package]] name = "basic-toml" -version = "0.1.9" +version = "0.1.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "823388e228f614e9558c6804262db37960ec8821856535f5c3f59913140558f8" +checksum = "ba62675e8242a4c4e806d12f11d136e626e6c8361d6b829310732241652a178a" dependencies = [ "serde", ] @@ -666,9 +654,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" [[package]] name = "bitflags" -version = "2.10.0" +version = "2.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3" +checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3" dependencies = [ "serde_core", ] @@ -681,24 +669,25 @@ checksum = "a1d084b0137aaa901caf9f1e8b21daa6aa24d41cd806e111335541eff9683bd6" [[package]] name = "bitpacking" -version = "0.9.2" +version = "0.9.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4c1d3e2bfd8d06048a179f7b17afc3188effa10385e7b00dc65af6aae732ea92" +checksum = "96a7139abd3d9cebf8cd6f920a389cf3dc9576172e32f4563f188cae3c3eb019" dependencies = [ "crunchy", ] [[package]] name = "blake3" -version = "1.8.2" +version = "1.8.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3888aaa89e4b2a40fca9848e400f6a658a5a3978de7be858e209cafa8be9a4a0" +checksum = "0aa83c34e62843d924f905e0f5c866eb1dd6545fc4d719e803d9ba6030371fce" dependencies = [ "arrayref", "arrayvec", "cc", "cfg-if", - "constant_time_eq 0.3.1", + "constant_time_eq 0.4.2", + "cpufeatures 0.3.0", ] [[package]] @@ -719,6 +708,15 @@ dependencies = [ "generic-array", ] +[[package]] +name = "block2" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdeb9d870516001442e364c5220d3574d2da8dc765554b4a617230d33fa58ef5" +dependencies = [ + "objc2", +] + [[package]] name = "blocking" version = "1.6.2" @@ -744,9 +742,9 @@ dependencies = [ [[package]] name = "bon" -version = "3.6.5" +version = "3.9.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "33d9ef19ae5263a138da9a86871eca537478ab0332a7770bac7e3f08b801f89f" +checksum = "f47dbe92550676ee653353c310dfb9cf6ba17ee70396e1f7cf0a2020ad49b2fe" dependencies = [ "bon-macros", "rustversion", @@ -754,11 +752,11 @@ dependencies = [ [[package]] name = "bon-macros" -version = "3.6.5" +version = "3.9.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "577ae008f2ca11ca7641bd44601002ee5ab49ef0af64846ce1ab6057218a5cc1" +checksum = "519bd3116aeeb42d5372c29d982d16d0170d3d4a5ed85fc7dd91642ffff3c67c" dependencies = [ - "darling 0.21.1", + "darling 0.23.0", "ident_case", "prettyplease", "proc-macro2", @@ -778,15 +776,15 @@ dependencies = [ [[package]] name = "bumpalo" -version = "3.16.0" +version = "3.20.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c" +checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb" [[package]] name = "bytemuck" -version = "1.16.3" +version = "1.25.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "102087e286b4677862ea56cf8fc58bb2cdfa8725c40ffb80fe3a008eb7f2fc83" +checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec" [[package]] name = "byteorder" @@ -808,9 +806,9 @@ checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33" [[package]] name = "bytesize" -version = "2.3.0" +version = "2.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "00f4369ba008f82b968b1acbe31715ec37bd45236fa0726605a36cc3060ea256" +checksum = "6bd91ee7b2422bcb158d90ef4d14f75ef67f340943fc4149891dcce8f8b972a3" [[package]] name = "bzip2" @@ -878,9 +876,9 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5" [[package]] name = "castaway" -version = "0.2.3" +version = "0.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0abae9be0aaf9ea96a3b1b8b1b55c602ca751eba1b1500220cea4ecbafe7c0d5" +checksum = "dec551ab6e7578819132c713a93c022a05d60159dc86e7a7050223577484c55a" dependencies = [ "rustversion", ] @@ -896,9 +894,9 @@ dependencies = [ [[package]] name = "cc" -version = "1.2.52" +version = "1.2.62" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cd4932aefd12402b36c60956a4fe0035421f544799057659ff86f923657aada3" +checksum = "a1dce859f0832a7d088c4f1119888ab94ef4b5d6795d1ce05afb7fe159d79f98" dependencies = [ "find-msvc-tools", "jobserver", @@ -957,7 +955,7 @@ checksum = "c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818" dependencies = [ "cfg-if", "cipher", - "cpufeatures 0.2.12", + "cpufeatures 0.2.17", ] [[package]] @@ -968,7 +966,7 @@ checksum = "6f8d983286843e49675a4b7a2d174efe136dc93a18d69130dd18198a6c167601" dependencies = [ "cfg-if", "cpufeatures 0.3.0", - "rand_core 0.10.0", + "rand_core 0.10.1", ] [[package]] @@ -986,16 +984,16 @@ dependencies = [ [[package]] name = "chrono" -version = "0.4.42" +version = "0.4.44" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "145052bdd345b87320e369255277e3fb5152762ad123a901ef5c262dd38fe8d2" +checksum = "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0" dependencies = [ "iana-time-zone", "js-sys", "num-traits", "serde", "wasm-bindgen", - "windows-link 0.2.1", + "windows-link", ] [[package]] @@ -1049,9 +1047,9 @@ dependencies = [ [[package]] name = "clap" -version = "4.5.53" +version = "4.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c9e340e012a1bf4935f5282ed1436d1489548e8f72308207ea5df0e23d2d03f8" +checksum = "1ddb117e43bbf7dacf0a4190fef4d345b9bad68dfc649cb349e7d17d28428e51" dependencies = [ "clap_builder", "clap_derive", @@ -1059,9 +1057,9 @@ dependencies = [ [[package]] name = "clap_builder" -version = "4.5.53" +version = "4.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d76b5d13eaa18c901fd2f7fca939fefe3a0727a953561fefdf3b2922b8569d00" +checksum = "714a53001bf66416adb0e2ef5ac857140e7dc3a0c48fb28b2f10762fc4b5069f" dependencies = [ "anstyle", "clap_lex", @@ -1070,9 +1068,9 @@ dependencies = [ [[package]] name = "clap_derive" -version = "4.5.49" +version = "4.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2a0b5487afeab2deb2ff4e03a807ad1a03ac532ff5a2cee5d86884440c7f7671" +checksum = "f2ce8604710f6733aa641a2b3731eaa1e8b3d9973d5e3565da11800813f997a9" dependencies = [ "heck 0.5.0", "proc-macro2", @@ -1082,15 +1080,15 @@ dependencies = [ [[package]] name = "clap_lex" -version = "0.7.5" +version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b94f61472cee1439c0b966b47e3aca9ae07e45d070759512cd390ea2bebc6675" +checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9" [[package]] name = "cmake" -version = "0.1.57" +version = "0.1.58" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "75443c44cd6b379beb8c5b45d85d0773baf31cce901fe7bb252f4eff3008ef7d" +checksum = "c0f78a02292a74a88ac736019ab962ece0bc380e3f977bf72e376c5d78ff0678" dependencies = [ "cc", ] @@ -1108,17 +1106,17 @@ dependencies = [ [[package]] name = "codspeed" -version = "4.2.1" +version = "4.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5f0d98d97fd75ca4489a1a0997820a6521531085e7c8a98941bd0e1264d567dd" +checksum = "d7ce4a32373a5c84f4fa785099b300b9b1796311abc122b9eb62c65fa615145d" dependencies = [ "anyhow", "cc", "colored", - "getrandom 0.2.15", + "getrandom 0.2.17", "glob", "libc", - "nix", + "nix 0.31.3", "serde", "serde_json", "statrs", @@ -1126,9 +1124,9 @@ dependencies = [ [[package]] name = "codspeed-criterion-compat" -version = "4.2.1" +version = "4.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d16fe2db207123f7b3a3b5cfff0c22f99469f7534145f3573f57f4c8a5653c2c" +checksum = "f5557c4e023f427ba208b849193c51c2ebd40534828490cd3f5f7f7fc0284ce5" dependencies = [ "clap", "codspeed", @@ -1141,9 +1139,9 @@ dependencies = [ [[package]] name = "codspeed-criterion-compat-walltime" -version = "4.2.1" +version = "4.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b035c7f9846b143aeabb3833f5b584023eb97b43ecbff3d997db74c4372df2bd" +checksum = "43ac19f0a5c3542301e9d011d658f93c3f550698ec8ba7d7c072692e7924c401" dependencies = [ "anes", "cast", @@ -1229,6 +1227,23 @@ dependencies = [ "static_assertions", ] +[[package]] +name = "compression-codecs" +version = "0.4.38" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce2548391e9c1929c21bf6aa2680af86fe4c1b33e6cea9ac1cfeec0bd11218cf" +dependencies = [ + "compression-core", + "flate2", + "memchr", +] + +[[package]] +name = "compression-core" +version = "0.4.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc14f565cf027a105f7a44ccf9e5b424348421a1d8952a8fc9d499d313107789" + [[package]] name = "concurrent-queue" version = "2.5.0" @@ -1240,14 +1255,25 @@ dependencies = [ [[package]] name = "console" -version = "0.15.8" +version = "0.15.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0e1f83fc076bd6dd27517eacdf25fef6c4dfe5f1d7448bafaaf3a26f13b5e4eb" +checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8" dependencies = [ "encode_unicode", - "lazy_static", "libc", - "windows-sys 0.52.0", + "once_cell", + "windows-sys 0.59.0", +] + +[[package]] +name = "console" +version = "0.16.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d64e8af5551369d19cf50138de61f1c42074ab970f74e99be916646777f8fc87" +dependencies = [ + "encode_unicode", + "libc", + "windows-sys 0.61.2", ] [[package]] @@ -1282,9 +1308,9 @@ checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc" [[package]] name = "constant_time_eq" -version = "0.3.1" +version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7c74b8349d32d297c9134b8c88677813a227df8f779daa29bfc29c183fe3dca6" +checksum = "3d52eff69cd5e647efe296129160853a42795992097e8af39800e1060caeea9b" [[package]] name = "core-foundation" @@ -1308,15 +1334,15 @@ dependencies = [ [[package]] name = "core-foundation-sys" -version = "0.8.6" +version = "0.8.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f" +checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" [[package]] name = "cpufeatures" -version = "0.2.12" +version = "0.2.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504" +checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280" dependencies = [ "libc", ] @@ -1332,9 +1358,9 @@ dependencies = [ [[package]] name = "crc32fast" -version = "1.4.2" +version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3" +checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511" dependencies = [ "cfg-if", ] @@ -1360,9 +1386,9 @@ dependencies = [ [[package]] name = "crossbeam-deque" -version = "0.8.5" +version = "0.8.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d" +checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51" dependencies = [ "crossbeam-epoch", "crossbeam-utils", @@ -1388,9 +1414,9 @@ dependencies = [ [[package]] name = "crossbeam-utils" -version = "0.8.20" +version = "0.8.21" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80" +checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28" [[package]] name = "crossterm" @@ -1398,11 +1424,11 @@ version = "0.28.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "829d955a0bb380ef178a640b91779e3987da38c9aea133b20614cfed8cdea9c6" dependencies = [ - "bitflags 2.10.0", + "bitflags 2.11.1", "crossterm_winapi", "mio", "parking_lot", - "rustix 0.38.41", + "rustix 0.38.44", "signal-hook", "signal-hook-mio", "winapi", @@ -1419,15 +1445,15 @@ dependencies = [ [[package]] name = "crunchy" -version = "0.2.2" +version = "0.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7" +checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" [[package]] name = "crypto-common" -version = "0.1.6" +version = "0.1.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3" +checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a" dependencies = [ "generic-array", "rand_core 0.6.4", @@ -1460,7 +1486,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be" dependencies = [ "cfg-if", - "cpufeatures 0.2.12", + "cpufeatures 0.2.17", "curve25519-dalek-derive", "digest", "fiat-crypto", @@ -1545,29 +1571,29 @@ dependencies = [ [[package]] name = "darling" -version = "0.20.10" +version = "0.20.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6f63b86c8a8826a49b8c21f08a2d07338eec8d900540f8630dc76284be802989" +checksum = "fc7f46116c46ff9ab3eb1597a45688b6715c6e628b5c133e288e709a29bcb4ee" dependencies = [ - "darling_core 0.20.10", - "darling_macro 0.20.10", + "darling_core 0.20.11", + "darling_macro 0.20.11", ] [[package]] name = "darling" -version = "0.21.1" +version = "0.23.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d6b136475da5ef7b6ac596c0e956e37bad51b85b987ff3d5e230e964936736b2" +checksum = "25ae13da2f202d56bd7f91c25fba009e7717a1e4a1cc98a76d844b65ae912e9d" dependencies = [ - "darling_core 0.21.1", - "darling_macro 0.21.1", + "darling_core 0.23.0", + "darling_macro 0.23.0", ] [[package]] name = "darling_core" -version = "0.20.10" +version = "0.20.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "95133861a8032aaea082871032f5815eb9e98cef03fa916ab4500513994df9e5" +checksum = "0d00b9596d185e565c2207a0b01f8bd1a135483d02d9b7b0a54b11da8d53412e" dependencies = [ "fnv", "ident_case", @@ -1579,11 +1605,10 @@ dependencies = [ [[package]] name = "darling_core" -version = "0.21.1" +version = "0.23.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b44ad32f92b75fb438b04b68547e521a548be8acc339a6dacc4a7121488f53e6" +checksum = "9865a50f7c335f53564bb694ef660825eb8610e0a53d3e11bf1b0d3df31e03b0" dependencies = [ - "fnv", "ident_case", "proc-macro2", "quote", @@ -1593,22 +1618,22 @@ dependencies = [ [[package]] name = "darling_macro" -version = "0.20.10" +version = "0.20.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806" +checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead" dependencies = [ - "darling_core 0.20.10", + "darling_core 0.20.11", "quote", "syn 2.0.117", ] [[package]] name = "darling_macro" -version = "0.21.1" +version = "0.23.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2b5be8a7a562d315a5b92a630c30cec6bcf663e6673f00fbb69cca66a6f521b9" +checksum = "ac3984ec7bd6cfa798e62b4a642426a5be0e68f9401cfc2a01e3fa9ea2fcdb8d" dependencies = [ - "darling_core 0.21.1", + "darling_core 0.23.0", "quote", "syn 2.0.117", ] @@ -1717,9 +1742,9 @@ dependencies = [ [[package]] name = "der" -version = "0.7.9" +version = "0.7.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f55bf8e7b65898637379c1b74eb1551107c8294ed26d855ceb9fd1a09cfc9bc0" +checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb" dependencies = [ "const-oid", "zeroize", @@ -1727,12 +1752,12 @@ dependencies = [ [[package]] name = "deranged" -version = "0.5.3" +version = "0.5.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d630bccd429a5bb5a64b5e94f693bfc48c9f8566418fda4c494cc94f911f87cc" +checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c" dependencies = [ "powerfmt", - "serde", + "serde_core", ] [[package]] @@ -1761,7 +1786,7 @@ version = "0.20.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2d5bcf7b024d6835cfb3d473887cd966994907effbe9227e8c8219824d06c4e8" dependencies = [ - "darling 0.20.10", + "darling 0.20.11", "proc-macro2", "quote", "syn 2.0.117", @@ -1788,11 +1813,11 @@ dependencies = [ [[package]] name = "derive_more" -version = "2.0.1" +version = "2.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "093242cf7570c207c83073cf82f79706fe7b8317e98620a47d5be7c3d8497678" +checksum = "d751e9e49156b02b44f9c1815bcb94b984cdcc4396ecc32521c739452808b134" dependencies = [ - "derive_more-impl 2.0.1", + "derive_more-impl 2.1.1", ] [[package]] @@ -1808,12 +1833,13 @@ dependencies = [ [[package]] name = "derive_more-impl" -version = "2.0.1" +version = "2.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bda628edc44c4bb645fbe0f758797143e4e07926f7ebf4e9bdfbd3d2ce621df3" +checksum = "799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb" dependencies = [ "proc-macro2", "quote", + "rustc_version", "syn 2.0.117", "unicode-xid", ] @@ -1856,6 +1882,16 @@ dependencies = [ "windows-sys 0.61.2", ] +[[package]] +name = "dispatch2" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38" +dependencies = [ + "bitflags 2.11.1", + "objc2", +] + [[package]] name = "displaydoc" version = "0.2.5" @@ -1869,9 +1905,9 @@ dependencies = [ [[package]] name = "downcast-rs" -version = "2.0.1" +version = "2.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ea8a8b81cacc08888170eef4d13b775126db426d0b348bee9d18c2c1eaf123cf" +checksum = "117240f60069e65410b3ae1bb213295bd828f707b5bec6596a1afc8793ce0cbc" [[package]] name = "dunce" @@ -1892,9 +1928,9 @@ dependencies = [ [[package]] name = "ed25519-dalek" -version = "2.1.1" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4a3daa8e81a3963a60642bcc1f90a670680bd4a77535faa384e9d1c79d620871" +checksum = "70e796c081cee67dc755e1a36a0a172b897fab85fc3f6bc48307991f64e4eca9" dependencies = [ "curve25519-dalek", "ed25519", @@ -1907,24 +1943,24 @@ dependencies = [ [[package]] name = "either" -version = "1.13.0" +version = "1.15.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0" +checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719" [[package]] name = "emojis" -version = "0.8.0" +version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "50c1c1870b766fc398e5f0526498d09c94b6de15be5fd769a28bbc804fb1b05d" +checksum = "0a4d5d50b0b58df5173d8ff1192b4d1422ceae5d981b30d4b6f8ed1d673a2bc4" dependencies = [ "phf", ] [[package]] name = "encode_unicode" -version = "0.3.6" +version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f" +checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0" [[package]] name = "encoding_rs" @@ -1937,18 +1973,18 @@ dependencies = [ [[package]] name = "equivalent" -version = "1.0.1" +version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5" +checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" [[package]] name = "errno" -version = "0.3.13" +version = "0.3.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "778e2ac28f6c47af28e4907f13ffd1e1ddbd400980a9abd7c8df189bf578a5ad" +checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" dependencies = [ "libc", - "windows-sys 0.60.2", + "windows-sys 0.61.2", ] [[package]] @@ -2151,8 +2187,8 @@ dependencies = [ "mime", "once_cell", "pulldown-cmark 0.9.6", - "rand 0.8.5", - "reqwest 0.13.2", + "rand 0.8.6", + "reqwest 0.13.3", "ruma", "serde", "serde_json", @@ -2285,9 +2321,9 @@ checksum = "9afc2bd4d5a73106dd53d10d73d3401c2f32730ba2c0b93ddb888a8983680471" [[package]] name = "fastrand" -version = "2.2.0" +version = "2.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "486f806e73c5707928240ddc295403b1b93c96a02038563881c4a2fd84b81ac4" +checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6" [[package]] name = "fiat-crypto" @@ -2297,9 +2333,9 @@ checksum = "28dea519a9695b9977216879a3ebfddf92f1c08c05d984f8996aecd6ecdc811d" [[package]] name = "find-msvc-tools" -version = "0.1.7" +version = "0.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f449e6c6c08c865631d4890cfacf252b3d396c9bcc83adb6623cdb02a8336c41" +checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582" [[package]] name = "findshlibs" @@ -2321,9 +2357,9 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80" [[package]] name = "flate2" -version = "1.1.5" +version = "1.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfe33edd8e85a12a67454e37f8c75e730830d83e313556ab9ebf9ee7fbeb3bfb" +checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c" dependencies = [ "crc32fast", "miniz_oxide", @@ -2396,7 +2432,7 @@ version = "0.13.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8640e34b88f7652208ce9e88b1a37a2ae95227d84abec377ccd3c5cfeb141ed4" dependencies = [ - "rustix 1.0.8", + "rustix 1.1.4", "windows-sys 0.59.0", ] @@ -2408,9 +2444,9 @@ checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c" [[package]] name = "futures" -version = "0.3.31" +version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876" +checksum = "8b147ee9d1f6d097cef9ce628cd2ee62288d963e16fb287bd9286455b241382d" dependencies = [ "futures-channel", "futures-core", @@ -2423,9 +2459,9 @@ dependencies = [ [[package]] name = "futures-channel" -version = "0.3.31" +version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10" +checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d" dependencies = [ "futures-core", "futures-sink", @@ -2433,15 +2469,15 @@ dependencies = [ [[package]] name = "futures-core" -version = "0.3.31" +version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e" +checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d" [[package]] name = "futures-executor" -version = "0.3.31" +version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f" +checksum = "baf29c38818342a3b26b5b923639e7b1f4a61fc5e76102d4b1981c6dc7a7579d" dependencies = [ "futures-core", "futures-task", @@ -2450,9 +2486,9 @@ dependencies = [ [[package]] name = "futures-io" -version = "0.3.31" +version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6" +checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718" [[package]] name = "futures-lite" @@ -2469,9 +2505,9 @@ dependencies = [ [[package]] name = "futures-macro" -version = "0.3.31" +version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650" +checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b" dependencies = [ "proc-macro2", "quote", @@ -2480,21 +2516,21 @@ dependencies = [ [[package]] name = "futures-sink" -version = "0.3.31" +version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7" +checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893" [[package]] name = "futures-task" -version = "0.3.31" +version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988" +checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393" [[package]] name = "futures-util" -version = "0.3.31" +version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81" +checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6" dependencies = [ "futures-channel", "futures-core", @@ -2504,7 +2540,6 @@ dependencies = [ "futures-task", "memchr", "pin-project-lite", - "pin-utils", "slab", ] @@ -2519,16 +2554,17 @@ dependencies = [ [[package]] name = "generator" -version = "0.8.7" +version = "0.8.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "605183a538e3e2a9c1038635cc5c2d194e2ee8fd0d1b66b8349fad7dbacce5a2" +checksum = "52f04ae4152da20c76fe800fa48659201d5cf627c5149ca0b707b69d7eef6cf9" dependencies = [ "cc", "cfg-if", "libc", "log", "rustversion", - "windows", + "windows-link", + "windows-result", ] [[package]] @@ -2552,9 +2588,9 @@ dependencies = [ [[package]] name = "getrandom" -version = "0.2.15" +version = "0.2.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7" +checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0" dependencies = [ "cfg-if", "js-sys", @@ -2587,7 +2623,7 @@ dependencies = [ "js-sys", "libc", "r-efi 6.0.0", - "rand_core 0.10.0", + "rand_core 0.10.1", "wasip2", "wasip3", "wasm-bindgen", @@ -2618,7 +2654,7 @@ version = "0.21.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "16de123c2e6c90ce3b573b7330de19be649080ec612033d397d72da265f1bd8b" dependencies = [ - "bitflags 2.10.0", + "bitflags 2.11.1", "futures-channel", "futures-core", "futures-executor", @@ -2734,16 +2770,16 @@ dependencies = [ [[package]] name = "h2" -version = "0.4.5" +version = "0.4.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fa82e28a107a8cc405f0839610bdc9b15f1e25ec7d696aa5cf173edbcb1486ab" +checksum = "171fefbc92fe4a4de27e0698d6a5b392d6a0e333506bc49133760b3bcf948733" dependencies = [ "atomic-waker", "bytes", "fnv", "futures-core", "futures-sink", - "http 1.3.1", + "http 1.4.0", "indexmap", "slab", "tokio", @@ -2753,12 +2789,13 @@ dependencies = [ [[package]] name = "half" -version = "2.4.1" +version = "2.7.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6dd08c532ae367adf81c312a4580bc67f1d0fe8bc9c460520283f4c0ff277888" +checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b" dependencies = [ "cfg-if", "crunchy", + "zerocopy", ] [[package]] @@ -2766,25 +2803,23 @@ name = "hashbrown" version = "0.14.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1" -dependencies = [ - "ahash", - "allocator-api2", -] [[package]] name = "hashbrown" -version = "0.15.2" +version = "0.15.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289" +checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" dependencies = [ + "allocator-api2", + "equivalent", "foldhash 0.1.5", ] [[package]] name = "hashbrown" -version = "0.16.1" +version = "0.17.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100" +checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" [[package]] name = "hashlink" @@ -2792,7 +2827,7 @@ version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7382cf6263419f2d8df38c55d7da83da5c18aef87fc7a7fc1fb1e344edfe14c1" dependencies = [ - "hashbrown 0.15.2", + "hashbrown 0.15.5", ] [[package]] @@ -2804,7 +2839,7 @@ dependencies = [ "base64 0.22.1", "bytes", "headers-core", - "http 1.3.1", + "http 1.4.0", "httpdate", "mime", "sha1", @@ -2816,7 +2851,7 @@ version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "54b4a22553d4242c49fddb9ba998a99962b5cc6f22cb5a3482bec22522403ce4" dependencies = [ - "http 1.3.1", + "http 1.4.0", ] [[package]] @@ -2831,12 +2866,6 @@ version = "0.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" -[[package]] -name = "hermit-abi" -version = "0.3.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024" - [[package]] name = "hermit-abi" version = "0.5.2" @@ -2878,13 +2907,13 @@ dependencies = [ [[package]] name = "hostname" -version = "0.4.1" +version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a56f203cd1c76362b69e3863fd987520ac36cf70a8c92627449b2f64a8cf7d65" +checksum = "617aaa3557aef3810a6369d0a99fac8a080891b68bd9f9812a1eeda0c0730cbd" dependencies = [ "cfg-if", "libc", - "windows-link 0.1.1", + "windows-link", ] [[package]] @@ -2916,12 +2945,11 @@ dependencies = [ [[package]] name = "http" -version = "1.3.1" +version = "1.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f4a85d31aea989eead29a3aaf9e1115a180df8282431156e533de47660892565" +checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a" dependencies = [ "bytes", - "fnv", "itoa", ] @@ -2941,27 +2969,27 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184" dependencies = [ "bytes", - "http 1.3.1", + "http 1.4.0", ] [[package]] name = "http-body-util" -version = "0.1.2" +version = "0.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "793429d76616a256bcb62c2a2ec2bed781c8307e797e2598c50010f2bee2544f" +checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a" dependencies = [ "bytes", - "futures-util", - "http 1.3.1", + "futures-core", + "http 1.4.0", "http-body", "pin-project-lite", ] [[package]] name = "httparse" -version = "1.9.4" +version = "1.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0fcc0b4a115bf80b728eb8ea024ad5bd707b615bfed49e0665b6e0f86fd082d9" +checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" [[package]] name = "httpdate" @@ -2971,22 +2999,21 @@ checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9" [[package]] name = "hyper" -version = "1.7.0" +version = "1.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eb3aa54a13a0dfe7fbe3a59e0c76093041720fdc77b110cc0fc260fafb4dc51e" +checksum = "6299f016b246a94207e63da54dbe807655bf9e00044f73ded42c3ac5305fbcca" dependencies = [ "atomic-waker", "bytes", "futures-channel", "futures-core", "h2", - "http 1.3.1", + "http 1.4.0", "http-body", "httparse", "httpdate", "itoa", "pin-project-lite", - "pin-utils", "smallvec", "tokio", "want", @@ -2994,19 +3021,17 @@ dependencies = [ [[package]] name = "hyper-rustls" -version = "0.27.2" +version = "0.27.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ee4be2c948921a1a5320b629c4193916ed787a7f7f293fd3f7f5a6c9de74155" +checksum = "33ca68d021ef39cf6463ab54c1d0f5daf03377b70561305bb89a8f83aab66e0f" dependencies = [ - "futures-util", - "http 1.3.1", + "http 1.4.0", "hyper", "hyper-util", - "rustls 0.23.38", - "rustls-native-certs 0.7.3", - "rustls-pki-types", + "rustls 0.23.40", + "rustls-native-certs 0.8.3", "tokio", - "tokio-rustls 0.26.0", + "tokio-rustls 0.26.4", "tower-service", ] @@ -3028,23 +3053,22 @@ dependencies = [ [[package]] name = "hyper-util" -version = "0.1.16" +version = "0.1.20" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8d9b05277c7e8da2c93a568989bb6207bef0112e8d17df7a6eda4a3cf143bc5e" +checksum = "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0" dependencies = [ "base64 0.22.1", "bytes", "futures-channel", - "futures-core", "futures-util", - "http 1.3.1", + "http 1.4.0", "http-body", "hyper", "ipnet", "libc", "percent-encoding", "pin-project-lite", - "socket2 0.6.0", + "socket2", "system-configuration", "tokio", "tower-service", @@ -3063,16 +3087,17 @@ dependencies = [ [[package]] name = "iana-time-zone" -version = "0.1.60" +version = "0.1.65" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141" +checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470" dependencies = [ "android_system_properties", "core-foundation-sys", "iana-time-zone-haiku", "js-sys", + "log", "wasm-bindgen", - "windows-core 0.52.0", + "windows-core", ] [[package]] @@ -3086,21 +3111,23 @@ dependencies = [ [[package]] name = "icu_collections" -version = "1.5.0" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "db2fa452206ebee18c4b5c2274dbf1de17008e874b4dc4f0aea9d01ca79e4526" +checksum = "2984d1cd16c883d7935b9e07e44071dca8d917fd52ecc02c04d5fa0b5a3f191c" dependencies = [ "displaydoc", + "potential_utf", + "utf8_iter", "yoke", "zerofrom", "zerovec", ] [[package]] -name = "icu_locid" -version = "1.5.0" +name = "icu_locale_core" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "13acbb8371917fc971be86fc8057c41a64b521c184808a698c02acc242dbf637" +checksum = "92219b62b3e2b4d88ac5119f8904c10f8f61bf7e95b640d25ba3075e6cac2c29" dependencies = [ "displaydoc", "litemap", @@ -3109,99 +3136,61 @@ dependencies = [ "zerovec", ] -[[package]] -name = "icu_locid_transform" -version = "1.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "01d11ac35de8e40fdeda00d9e1e9d92525f3f9d887cdd7aa81d727596788b54e" -dependencies = [ - "displaydoc", - "icu_locid", - "icu_locid_transform_data", - "icu_provider", - "tinystr", - "zerovec", -] - -[[package]] -name = "icu_locid_transform_data" -version = "1.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fdc8ff3388f852bede6b579ad4e978ab004f139284d7b28715f773507b946f6e" - [[package]] name = "icu_normalizer" -version = "1.5.0" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "19ce3e0da2ec68599d193c93d088142efd7f9c5d6fc9b803774855747dc6a84f" +checksum = "c56e5ee99d6e3d33bd91c5d85458b6005a22140021cc324cea84dd0e72cff3b4" dependencies = [ - "displaydoc", "icu_collections", "icu_normalizer_data", "icu_properties", "icu_provider", "smallvec", - "utf16_iter", - "utf8_iter", - "write16", "zerovec", ] [[package]] name = "icu_normalizer_data" -version = "1.5.0" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8cafbf7aa791e9b22bec55a167906f9e1215fd475cd22adfcf660e03e989516" +checksum = "da3be0ae77ea334f4da67c12f149704f19f81d1adf7c51cf482943e84a2bad38" [[package]] name = "icu_properties" -version = "1.5.1" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "93d6020766cfc6302c15dbbc9c8778c37e62c14427cb7f6e601d849e092aeef5" +checksum = "bee3b67d0ea5c2cca5003417989af8996f8604e34fb9ddf96208a033901e70de" dependencies = [ - "displaydoc", "icu_collections", - "icu_locid_transform", + "icu_locale_core", "icu_properties_data", "icu_provider", - "tinystr", + "zerotrie", "zerovec", ] [[package]] name = "icu_properties_data" -version = "1.5.0" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "67a8effbc3dd3e4ba1afa8ad918d5684b8868b3b26500753effea8d2eed19569" +checksum = "8e2bbb201e0c04f7b4b3e14382af113e17ba4f63e2c9d2ee626b720cbce54a14" [[package]] name = "icu_provider" -version = "1.5.0" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6ed421c8a8ef78d3e2dbc98a973be2f3770cb42b606e3ab18d6237c4dfde68d9" +checksum = "139c4cf31c8b5f33d7e199446eff9c1e02decfc2f0eec2c8d71f65befa45b421" dependencies = [ "displaydoc", - "icu_locid", - "icu_provider_macros", - "stable_deref_trait", - "tinystr", + "icu_locale_core", "writeable", "yoke", "zerofrom", + "zerotrie", "zerovec", ] -[[package]] -name = "icu_provider_macros" -version = "1.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1ec89e9337638ecdc08744df490b221a7399bf8d164eb52a665454e60e075ad6" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.117", -] - [[package]] name = "id-arena" version = "2.3.0" @@ -3227,9 +3216,9 @@ dependencies = [ [[package]] name = "idna_adapter" -version = "1.2.0" +version = "1.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "daca1df1c957320b2cf139ac61e7bd64fed304c5040df000a745aa1de3b4ef71" +checksum = "cb68373c0d6620ef8105e855e7745e18b0d00d3bdb07fb532e434244cdb9a714" dependencies = [ "icu_normalizer", "icu_properties", @@ -3237,9 +3226,9 @@ dependencies = [ [[package]] name = "image" -version = "0.25.9" +version = "0.25.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e6506c6c10786659413faa717ceebcb8f70731c0a60cbae39795fdf114519c1a" +checksum = "85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104" dependencies = [ "bytemuck", "byteorder-lite", @@ -3256,7 +3245,7 @@ dependencies = [ "archery", "bitmaps", "imbl-sized-chunks", - "rand_core 0.9.3", + "rand_core 0.9.5", "rand_xoshiro", "serde", "version_check", @@ -3303,18 +3292,18 @@ dependencies = [ [[package]] name = "indenter" -version = "0.3.3" +version = "0.3.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce23b50ad8242c51a442f3ff322d56b02f08852c77e4c0b4d3fd684abc89c683" +checksum = "964de6e86d545b246d84badc0fef527924ace5134f30641c203ef52ba83f58d5" [[package]] name = "indexmap" -version = "2.12.1" +version = "2.14.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0ad4bb2b565bca0645f4d68c5c9af97fba094e9791da685bf83cb5f3ce74acf2" +checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9" dependencies = [ "equivalent", - "hashbrown 0.16.1", + "hashbrown 0.17.1", "serde", "serde_core", ] @@ -3330,9 +3319,9 @@ dependencies = [ [[package]] name = "inout" -version = "0.1.3" +version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a0c10553d664a4d0bcff9f4215d0aac67a639cc68ef660840afe309b807bc9f5" +checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01" dependencies = [ "block-padding", "generic-array", @@ -3340,25 +3329,26 @@ dependencies = [ [[package]] name = "insta" -version = "1.44.1" +version = "1.47.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e8732d3774162a0851e3f2b150eb98f31a9885dd75985099421d393385a01dfd" +checksum = "7b4a6248eb93a4401ed2f37dfe8ea592d3cf05b7cf4f8efa867b6895af7e094e" dependencies = [ - "console", + "console 0.16.3", "once_cell", "pest", "pest_derive", "serde", "similar", + "tempfile", ] [[package]] name = "instability" -version = "0.3.7" +version = "0.3.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0bf9fed6d91cfb734e7476a06bde8300a1b94e217e1b523b6f0cd1a01998c71d" +checksum = "5eb2d60ef19920a3a9193c3e371f726ec1dafc045dac788d0fb3704272458971" dependencies = [ - "darling 0.20.10", + "darling 0.23.0", "indoc", "proc-macro2", "quote", @@ -3367,29 +3357,19 @@ dependencies = [ [[package]] name = "ipnet" -version = "2.9.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f518f335dce6725a761382244631d86cf0ccb2863413590b31338feb467f9c3" - -[[package]] -name = "iri-string" -version = "0.7.8" +version = "2.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dbc5ebe9c3a1a7a5127f920a418f7585e9e758e911d0466ed004f393b0e380b2" -dependencies = [ - "memchr", - "serde", -] +checksum = "d98f6fed1fde3f8c21bc40a1abb88dd75e67924f9cffc3ef95607bad8017f8e2" [[package]] name = "is-terminal" -version = "0.4.16" +version = "0.4.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e04d7f318608d35d4b61ddd75cbdaee86b023ebe2bd5a66ee0915f0bf93095a9" +checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46" dependencies = [ - "hermit-abi 0.5.2", + "hermit-abi", "libc", - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] @@ -3410,6 +3390,15 @@ dependencies = [ "either", ] +[[package]] +name = "itertools" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569" +dependencies = [ + "either", +] + [[package]] name = "itertools" version = "0.13.0" @@ -3430,9 +3419,9 @@ dependencies = [ [[package]] name = "itoa" -version = "1.0.11" +version = "1.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" [[package]] name = "jni" @@ -3443,31 +3432,84 @@ dependencies = [ "cesu8", "cfg-if", "combine", - "jni-sys", + "jni-sys 0.3.1", "log", - "thiserror 1.0.63", + "thiserror 1.0.69", "walkdir", "windows-sys 0.45.0", ] [[package]] -name = "jni-sys" -version = "0.3.0" +name = "jni" +version = "0.22.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130" +checksum = "5efd9a482cf3a427f00d6b35f14332adc7902ce91efb778580e180ff90fa3498" +dependencies = [ + "cfg-if", + "combine", + "jni-macros", + "jni-sys 0.4.1", + "log", + "simd_cesu8", + "thiserror 2.0.18", + "walkdir", + "windows-link", +] [[package]] -name = "jobserver" -version = "0.1.32" +name = "jni-macros" +version = "0.22.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "48d1dbcbbeb6a7fec7e059840aa538bd62aaccf972c7346c4d9d2059312853d0" +checksum = "a00109accc170f0bdb141fed3e393c565b6f5e072365c3bd58f5b062591560a3" dependencies = [ - "libc", + "proc-macro2", + "quote", + "rustc_version", + "simd_cesu8", + "syn 2.0.117", ] [[package]] -name = "jpeg-decoder" -version = "0.3.2" +name = "jni-sys" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41a652e1f9b6e0275df1f15b32661cf0d4b78d4d87ddec5e0c3c20f097433258" +dependencies = [ + "jni-sys 0.4.1", +] + +[[package]] +name = "jni-sys" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6377a88cb3910bee9b0fa88d4f42e1d2da8e79915598f65fb0c7ee14c878af2" +dependencies = [ + "jni-sys-macros", +] + +[[package]] +name = "jni-sys-macros" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38c0b942f458fe50cdac086d2f946512305e5631e720728f2a61aabcd47a6264" +dependencies = [ + "quote", + "syn 2.0.117", +] + +[[package]] +name = "jobserver" +version = "0.1.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33" +dependencies = [ + "getrandom 0.3.4", + "libc", +] + +[[package]] +name = "jpeg-decoder" +version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "00810f1d8b74be64b13dbf3db89ac67740615d6c891f0e7b6179326533011a07" dependencies = [ @@ -3476,10 +3518,12 @@ dependencies = [ [[package]] name = "js-sys" -version = "0.3.91" +version = "0.3.98" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b49715b7073f385ba4bc528e5747d02e66cb39c6146efb66b781f131f0fb399c" +checksum = "67df7112613f8bfd9150013a0314e196f4800d3201ae742489d999db2f979f08" dependencies = [ + "cfg-if", + "futures-util", "once_cell", "wasm-bindgen", ] @@ -3533,7 +3577,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6a9353d43a802ba22de0de749f4aa51f3414a6a9b5037559eaac65584db65218" dependencies = [ "goblin 0.9.3", - "jni-sys", + "jni-sys 0.3.1", "libc", "windows-sys 0.60.2", ] @@ -3592,9 +3636,9 @@ checksum = "0c2cdeb66e45e9f36bfad5bbdb4d2384e70936afbee843c6f6543f0c551ebb25" [[package]] name = "libc" -version = "0.2.175" +version = "0.2.186" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6a82ae493e598baaea5209805c49bbf2ea7de956d50d7da0da1164f9c6d28543" +checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66" [[package]] name = "libloading" @@ -3603,22 +3647,21 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55" dependencies = [ "cfg-if", - "windows-link 0.2.1", + "windows-link", ] [[package]] name = "libm" -version = "0.2.15" +version = "0.2.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de" +checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981" [[package]] name = "libredox" -version = "0.1.3" +version = "0.1.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d" +checksum = "e02f3bb43d335493c96bf3fd3a321600bf6bd07ed34bc64118e9293bdffea46c" dependencies = [ - "bitflags 2.10.0", "libc", ] @@ -3640,7 +3683,7 @@ source = "git+https://github.com/onestacked/livekit-rust-sdks?branch=EC-compat-c dependencies = [ "cxx", "glib", - "jni", + "jni 0.21.1", "js-sys", "lazy_static", "livekit-protocol", @@ -3649,7 +3692,7 @@ dependencies = [ "parking_lot", "serde", "serde_json", - "thiserror 1.0.63", + "thiserror 1.0.69", "tokio", "wasm-bindgen", "wasm-bindgen-futures", @@ -3668,21 +3711,21 @@ dependencies = [ [[package]] name = "linux-raw-sys" -version = "0.4.14" +version = "0.4.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89" +checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab" [[package]] name = "linux-raw-sys" -version = "0.9.4" +version = "0.12.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12" +checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53" [[package]] name = "litemap" -version = "0.7.4" +version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4ee93343901ab17bd981295f2cf0026d4ad018c7c31ba84549a4ddbb47a45104" +checksum = "92daf443525c4cce67b150400bc2316076100ce0b3686209eb8cf3c31612e6f0" [[package]] name = "livekit" @@ -3708,7 +3751,7 @@ dependencies = [ "serde", "serde_json", "sha2", - "thiserror 1.0.63", + "thiserror 1.0.69", "tokio", ] @@ -3720,7 +3763,7 @@ dependencies = [ "async-tungstenite", "base64 0.21.7", "futures-util", - "http 1.3.1", + "http 1.4.0", "jsonwebtoken", "livekit-protocol", "livekit-runtime", @@ -3728,14 +3771,14 @@ dependencies = [ "parking_lot", "pbjson-types", "prost 0.12.6", - "rand 0.9.2", + "rand 0.9.4", "reqwest 0.12.28", "rustls-native-certs 0.6.3", "scopeguard", "serde", "serde_json", "sha2", - "thiserror 1.0.63", + "thiserror 1.0.69", "tokio", "tokio-rustls 0.24.1", "tokio-tungstenite", @@ -3754,7 +3797,7 @@ dependencies = [ "pbjson-types", "prost 0.12.6", "serde", - "thiserror 1.0.63", + "thiserror 1.0.69", "tokio", ] @@ -3769,19 +3812,18 @@ dependencies = [ [[package]] name = "lock_api" -version = "0.4.12" +version = "0.4.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "07af8b9cdd281b7915f413fa73f29ebd5d55d0d3f0155584dade1ff18cea1b17" +checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965" dependencies = [ - "autocfg", "scopeguard", ] [[package]] name = "log" -version = "0.4.27" +version = "0.4.29" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94" +checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897" dependencies = [ "value-bag", ] @@ -3811,11 +3853,11 @@ dependencies = [ [[package]] name = "lru" -version = "0.12.3" +version = "0.12.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d3262e75e648fce39813cb56ac41f3c3e3f65217ebf3844d818d1f9398cfb0dc" +checksum = "234cf4f4a04dc1f57e24b96cc0cd600cf2af460d4161ac5ecdd0af8e1f3b2a38" dependencies = [ - "hashbrown 0.14.5", + "hashbrown 0.15.5", ] [[package]] @@ -3912,19 +3954,19 @@ checksum = "47e1ffaa40ddd1f3ed91f717a33c8c0ee23fff369e3aa8772b9605cc1d22f4c3" [[package]] name = "matrix-pickle" -version = "0.2.1" +version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4e2551de3bba2cc65b52dc6b268df6114011fe118ac24870fbcf1b35537bd721" +checksum = "6c34e6db65145740459f2ca56623b40cd4e6000ffae2a7d91515fa82aa935dbf" dependencies = [ "matrix-pickle-derive", - "thiserror 1.0.63", + "thiserror 2.0.18", ] [[package]] name = "matrix-pickle-derive" -version = "0.2.1" +version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f75de44c3120d78e978adbcf6d453b20ba011f3c46363e52d1dbbc72f545e9fb" +checksum = "a962fc9981f823f6555416dcb2ae9ae67ca412d767ee21ecab5150113ee6285b" dependencies = [ "proc-macro-crate", "proc-macro-error2", @@ -3963,7 +4005,7 @@ dependencies = [ "futures-executor", "futures-util", "gloo-timers", - "http 1.3.1", + "http 1.4.0", "imbl", "indexmap", "insta", @@ -3986,9 +4028,9 @@ dependencies = [ "pin-project-lite", "proptest", "rand 0.10.1", - "reqwest 0.13.2", + "reqwest 0.13.3", "ruma", - "rustls 0.23.38", + "rustls 0.23.40", "rustls-native-certs 0.8.3", "rustls-pki-types", "serde", @@ -4028,7 +4070,7 @@ dependencies = [ "assert_matches2", "assign", "async-trait", - "bitflags 2.10.0", + "bitflags 2.11.1", "decancer", "eyeball", "eyeball-im", @@ -4037,7 +4079,7 @@ dependencies = [ "getrandom 0.3.4", "gloo-timers", "growable-bloom-filter", - "http 1.3.1", + "http 1.4.0", "matrix-sdk-common", "matrix-sdk-crypto", "matrix-sdk-store-encryption", @@ -4112,7 +4154,7 @@ dependencies = [ "futures-util", "hkdf", "hmac", - "http 1.3.1", + "http 1.4.0", "insta", "itertools 0.14.0", "js_option", @@ -4151,7 +4193,7 @@ dependencies = [ "assert_matches2", "futures-util", "hmac", - "http 1.3.1", + "http 1.4.0", "js_int", "matrix-sdk-common", "matrix-sdk-crypto", @@ -4185,7 +4227,7 @@ dependencies = [ "eyeball-im", "futures-executor", "futures-util", - "jni", + "jni 0.21.1", "jvm-getter", "language-tags", "log-panics", @@ -4199,7 +4241,7 @@ dependencies = [ "once_cell", "paranoid-android", "ruma", - "rustls-platform-verifier", + "rustls-platform-verifier 0.6.2", "sentry", "sentry-tracing", "serde", @@ -4280,7 +4322,7 @@ dependencies = [ "futures", "futures-core", "futures-util", - "http 1.3.1", + "http 1.4.0", "json-structural-diff", "matrix-sdk", "matrix-sdk-base", @@ -4289,7 +4331,7 @@ dependencies = [ "matrix-sdk-test-utils", "matrix-sdk-ui", "rand 0.10.1", - "reqwest 0.13.2", + "reqwest 0.13.3", "serde_json", "similar-asserts", "stream_assert", @@ -4322,7 +4364,7 @@ dependencies = [ "matrix-sdk", "matrix-sdk-base", "matrix-sdk-crypto", - "rand 0.8.5", + "rand 0.8.6", "reqwest 0.12.28", "ruma", "serde", @@ -4395,7 +4437,7 @@ dependencies = [ "base64 0.22.1", "blake3", "chacha20poly1305", - "getrandom 0.2.15", + "getrandom 0.2.17", "getrandom 0.4.2", "hmac", "pbkdf2 0.12.2", @@ -4415,7 +4457,7 @@ dependencies = [ "as_variant", "ctor", "getrandom 0.4.2", - "http 1.3.1", + "http 1.4.0", "insta", "matrix-sdk-common", "matrix-sdk-test-macros", @@ -4458,7 +4500,7 @@ dependencies = [ "async-rx", "async-stream", "async_cell", - "bitflags 2.10.0", + "bitflags 2.11.1", "chrono", "emojis", "eyeball", @@ -4504,7 +4546,7 @@ dependencies = [ "accessory", "cfg-if", "delegate-display", - "derive_more 2.0.1", + "derive_more 2.1.1", "fancy_constructor", "futures-core", "js-sys", @@ -4551,9 +4593,9 @@ checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79" [[package]] name = "memmap2" -version = "0.9.7" +version = "0.9.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "483758ad303d734cec05e5c12b41d7e93e6a6390c5e9dae6bdeb7c1259012d28" +checksum = "714098028fe011992e1c3962653c96b2d578c4b4bce9036e15ff220319b1e0e3" dependencies = [ "libc", ] @@ -4598,22 +4640,21 @@ dependencies = [ [[package]] name = "mio" -version = "1.0.2" +version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "80e04d1dcff3aae0704555fe5fee3bcfaf3d1fdf8a7e521d5b9d2b42acb52cec" +checksum = "50b7e5b27aa02a74bac8c3f23f448f8d87ff11f92d3aac1a6ed369ee08cc56c1" dependencies = [ - "hermit-abi 0.3.9", "libc", "log", "wasi", - "windows-sys 0.52.0", + "windows-sys 0.61.2", ] [[package]] name = "moxcms" -version = "0.7.5" +version = "0.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ddd32fa8935aeadb8a8a6b6b351e40225570a37c43de67690383d87ef170cd08" +checksum = "bb85c154ba489f01b25c0d36ae69a87e4a1c73a72631fc6c0eb6dde34a73e44b" dependencies = [ "num-traits", "pxfm", @@ -4663,17 +4704,17 @@ checksum = "2195bf6aa996a481483b29d62a7663eed3fe39600c460e323f8ff41e90bdd89b" [[package]] name = "native-tls" -version = "0.2.15" +version = "0.2.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6cdede44f9a69cab2899a2049e2c3bd49bf911a157f6a3353d4a91c61abbce44" +checksum = "465500e14ea162429d264d44189adc38b199b62b1c21eea9f69e4b73cb03bbf2" dependencies = [ "libc", "log", "openssl", - "openssl-probe 0.1.6", + "openssl-probe 0.2.1", "openssl-sys", "schannel", - "security-framework 2.11.1", + "security-framework 3.7.0", "security-framework-sys", "tempfile", ] @@ -4684,7 +4725,7 @@ version = "0.5.0+25.2.9519653" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8c196769dd60fd4f363e11d948139556a344e79d451aeb2fa2fd040738ef7691" dependencies = [ - "jni-sys", + "jni-sys 0.3.1", ] [[package]] @@ -4699,7 +4740,19 @@ version = "0.30.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "74523f3a35e05aba87a1d978330aef40f67b0304ac79c1c00b294c9830543db6" dependencies = [ - "bitflags 2.10.0", + "bitflags 2.11.1", + "cfg-if", + "cfg_aliases", + "libc", +] + +[[package]] +name = "nix" +version = "0.31.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf20d2fde8ff38632c426f1165ed7436270b44f199fc55284c38276f9db47c3d" +dependencies = [ + "bitflags 2.11.1", "cfg-if", "cfg_aliases", "libc", @@ -4717,18 +4770,18 @@ dependencies = [ [[package]] name = "nu-ansi-term" -version = "0.50.1" +version = "0.50.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d4a28e057d01f97e61255210fcff094d74ed0466038633e95017f5beb68e4399" +checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5" dependencies = [ - "windows-sys 0.52.0", + "windows-sys 0.61.2", ] [[package]] name = "num-conv" -version = "0.2.0" +version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf97ec579c3c42f953ef76dbf8d55ac91fb219dde70e49aa4a6b7d74e9919050" +checksum = "c6673768db2d862beb9b39a78fdcb1a69439615d5794a1be50caa9bc92c81967" [[package]] name = "num-traits" @@ -4746,7 +4799,7 @@ version = "1.17.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b" dependencies = [ - "hermit-abi 0.5.2", + "hermit-abi", "libc", ] @@ -4767,14 +4820,14 @@ checksum = "51e219e79014df21a225b1860a479e2dcd7cbd9130f4defd4bd0e191ea31d67d" dependencies = [ "base64 0.22.1", "chrono", - "getrandom 0.2.15", - "http 1.3.1", - "rand 0.8.5", + "getrandom 0.2.17", + "http 1.4.0", + "rand 0.8.6", "serde", "serde_json", "serde_path_to_error", "sha2", - "thiserror 1.0.63", + "thiserror 1.0.69", "url", ] @@ -4785,7 +4838,166 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "234fb5c965bbce983ee5de636a7a51d6a3223da8067ea02f9ab2d2d78ac08be2" dependencies = [ "oauth2", - "reqwest 0.13.2", + "reqwest 0.13.3", +] + +[[package]] +name = "objc2" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f" +dependencies = [ + "objc2-encode", +] + +[[package]] +name = "objc2-cloud-kit" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "73ad74d880bb43877038da939b7427bba67e9dd42004a18b809ba7d87cee241c" +dependencies = [ + "bitflags 2.11.1", + "objc2", + "objc2-foundation", +] + +[[package]] +name = "objc2-core-data" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b402a653efbb5e82ce4df10683b6b28027616a2715e90009947d50b8dd298fa" +dependencies = [ + "objc2", + "objc2-foundation", +] + +[[package]] +name = "objc2-core-foundation" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536" +dependencies = [ + "bitflags 2.11.1", + "dispatch2", + "objc2", +] + +[[package]] +name = "objc2-core-graphics" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e022c9d066895efa1345f8e33e584b9f958da2fd4cd116792e15e07e4720a807" +dependencies = [ + "bitflags 2.11.1", + "dispatch2", + "objc2", + "objc2-core-foundation", + "objc2-io-surface", +] + +[[package]] +name = "objc2-core-image" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5d563b38d2b97209f8e861173de434bd0214cf020e3423a52624cd1d989f006" +dependencies = [ + "objc2", + "objc2-foundation", +] + +[[package]] +name = "objc2-core-location" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ca347214e24bc973fc025fd0d36ebb179ff30536ed1f80252706db19ee452009" +dependencies = [ + "objc2", + "objc2-foundation", +] + +[[package]] +name = "objc2-core-text" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0cde0dfb48d25d2b4862161a4d5fcc0e3c24367869ad306b0c9ec0073bfed92d" +dependencies = [ + "bitflags 2.11.1", + "objc2", + "objc2-core-foundation", + "objc2-core-graphics", +] + +[[package]] +name = "objc2-encode" +version = "4.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33" + +[[package]] +name = "objc2-foundation" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272" +dependencies = [ + "bitflags 2.11.1", + "block2", + "libc", + "objc2", + "objc2-core-foundation", +] + +[[package]] +name = "objc2-io-surface" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "180788110936d59bab6bd83b6060ffdfffb3b922ba1396b312ae795e1de9d81d" +dependencies = [ + "bitflags 2.11.1", + "objc2", + "objc2-core-foundation", +] + +[[package]] +name = "objc2-quartz-core" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96c1358452b371bf9f104e21ec536d37a650eb10f7ee379fff67d2e08d537f1f" +dependencies = [ + "bitflags 2.11.1", + "objc2", + "objc2-core-foundation", + "objc2-foundation", +] + +[[package]] +name = "objc2-ui-kit" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d87d638e33c06f577498cbcc50491496a3ed4246998a7fbba7ccb98b1e7eab22" +dependencies = [ + "bitflags 2.11.1", + "block2", + "objc2", + "objc2-cloud-kit", + "objc2-core-data", + "objc2-core-foundation", + "objc2-core-graphics", + "objc2-core-image", + "objc2-core-location", + "objc2-core-text", + "objc2-foundation", + "objc2-quartz-core", + "objc2-user-notifications", +] + +[[package]] +name = "objc2-user-notifications" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9df9128cbbfef73cda168416ccf7f837b62737d748333bfe9ab71c245d76613e" +dependencies = [ + "objc2", + "objc2-foundation", ] [[package]] @@ -4827,7 +5039,7 @@ version = "0.10.79" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bf0b434746ee2832f4f0baf10137e1cabb18cbe6912c69e2e33263c45250f542" dependencies = [ - "bitflags 2.10.0", + "bitflags 2.11.1", "cfg-if", "foreign-types", "libc", @@ -4854,9 +5066,9 @@ checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e" [[package]] name = "openssl-probe" -version = "0.2.0" +version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9f50d9b3dabb09ecd771ad0aa242ca6894994c130308ca3d7684634df8037391" +checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe" [[package]] name = "openssl-sys" @@ -4878,13 +5090,18 @@ checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d" [[package]] name = "os_info" -version = "3.11.0" +version = "3.14.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "41fc863e2ca13dc2d5c34fb22ea4a588248ac14db929616ba65c45f21744b1e9" +checksum = "e4022a17595a00d6a369236fdae483f0de7f0a339960a53118b818238e132224" dependencies = [ + "android_system_properties", "log", + "nix 0.30.1", + "objc2", + "objc2-foundation", + "objc2-ui-kit", "serde", - "windows-sys 0.52.0", + "windows-sys 0.61.2", ] [[package]] @@ -4898,9 +5115,9 @@ dependencies = [ [[package]] name = "owo-colors" -version = "4.2.2" +version = "4.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "48dd4f4a2c8405440fd0462561f0e5806bd0f77e86f51c761481bdd4018b545e" +checksum = "d211803b9b6b570f68772237e415a029d5a50c65d382910b879fb19d3271f94d" [[package]] name = "paranoid-android" @@ -4918,15 +5135,15 @@ dependencies = [ [[package]] name = "parking" -version = "2.2.0" +version = "2.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bb813b8af86854136c6922af0598d719255ecb2179515e6e7730d468f05c9cae" +checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba" [[package]] name = "parking_lot" -version = "0.12.3" +version = "0.12.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27" +checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a" dependencies = [ "lock_api", "parking_lot_core", @@ -4934,15 +5151,15 @@ dependencies = [ [[package]] name = "parking_lot_core" -version = "0.9.10" +version = "0.9.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8" +checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1" dependencies = [ "cfg-if", "libc", "redox_syscall", "smallvec", - "windows-targets 0.52.6", + "windows-link", ] [[package]] @@ -5034,20 +5251,19 @@ checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" [[package]] name = "pest" -version = "2.8.0" +version = "2.8.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "198db74531d58c70a361c42201efde7e2591e976d518caf7662a47dc5720e7b6" +checksum = "e0848c601009d37dfa3430c4666e147e49cdcf1b92ecd3e63657d8a5f19da662" dependencies = [ "memchr", - "thiserror 2.0.18", "ucd-trie", ] [[package]] name = "pest_derive" -version = "2.8.0" +version = "2.8.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d725d9cfd79e87dccc9341a2ef39d1b6f6353d68c4b33c177febbe1a402c97c5" +checksum = "11f486f1ea21e6c10ed15d5a7c77165d0ee443402f0780849d1768e7d9d6fe77" dependencies = [ "pest", "pest_generator", @@ -5055,9 +5271,9 @@ dependencies = [ [[package]] name = "pest_generator" -version = "2.8.0" +version = "2.8.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "db7d01726be8ab66ab32f9df467ae8b1148906685bbe75c82d1e65d7f5b3f841" +checksum = "8040c4647b13b210a963c1ed407c1ff4fdfa01c31d6d2a098218702e6664f94f" dependencies = [ "pest", "pest_meta", @@ -5068,11 +5284,10 @@ dependencies = [ [[package]] name = "pest_meta" -version = "2.8.0" +version = "2.8.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f9f832470494906d1fca5329f8ab5791cc60beb230c74815dff541cbd2b5ca0" +checksum = "89815c69d36021a140146f26659a81d6c2afa33d216d736dd4be5381a7362220" dependencies = [ - "once_cell", "pest", "sha2", ] @@ -5128,9 +5343,9 @@ dependencies = [ [[package]] name = "pin-project-lite" -version = "0.2.16" +version = "0.2.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b" +checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" [[package]] name = "pin-utils" @@ -5161,9 +5376,9 @@ dependencies = [ [[package]] name = "pkg-config" -version = "0.3.30" +version = "0.3.33" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec" +checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e" [[package]] name = "plain" @@ -5173,9 +5388,9 @@ checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6" [[package]] name = "plotters" -version = "0.3.6" +version = "0.3.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a15b6eccb8484002195a3e44fe65a4ce8e93a625797a063735536fd59cb01cf3" +checksum = "5aeb6f403d7a4911efb1e33402027fc44f29b5bf6def3effcc22d7bb75f2b747" dependencies = [ "num-traits", "plotters-backend", @@ -5186,15 +5401,15 @@ dependencies = [ [[package]] name = "plotters-backend" -version = "0.3.6" +version = "0.3.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "414cec62c6634ae900ea1c56128dfe87cf63e7caece0852ec76aba307cebadb7" +checksum = "df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a" [[package]] name = "plotters-svg" -version = "0.3.6" +version = "0.3.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "81b30686a7d9c3e010b84284bdd26a29f2138574f52f5eb6f794fc0ad924e705" +checksum = "51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670" dependencies = [ "plotters-backend", ] @@ -5207,9 +5422,9 @@ checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218" dependencies = [ "cfg-if", "concurrent-queue", - "hermit-abi 0.5.2", + "hermit-abi", "pin-project-lite", - "rustix 1.0.8", + "rustix 1.1.4", "windows-sys 0.61.2", ] @@ -5219,11 +5434,20 @@ version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8159bd90725d2df49889a078b54f4f79e87f1f8a8444194cdca81d38f5393abf" dependencies = [ - "cpufeatures 0.2.12", + "cpufeatures 0.2.17", "opaque-debug", "universal-hash", ] +[[package]] +name = "potential_utf" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0103b1cef7ec0cf76490e969665504990193874ea05c85ff9bab8b911d0a0564" +dependencies = [ + "zerovec", +] + [[package]] name = "powerfmt" version = "0.2.0" @@ -5232,9 +5456,12 @@ checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391" [[package]] name = "ppv-lite86" -version = "0.2.17" +version = "0.2.21" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de" +checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9" +dependencies = [ + "zerocopy", +] [[package]] name = "precomputed-hash" @@ -5244,9 +5471,9 @@ checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c" [[package]] name = "prettyplease" -version = "0.2.34" +version = "0.2.37" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6837b9e10d61f45f987d50808f83d1ee3d206c66acf650c3e4ae2e1f6ddedf55" +checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" dependencies = [ "proc-macro2", "syn 2.0.117", @@ -5293,13 +5520,13 @@ dependencies = [ [[package]] name = "proptest" -version = "1.9.0" +version = "1.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bee689443a2bd0a16ab0348b52ee43e3b2d1b1f931c8aa5c9f8de4c86fbe8c40" +checksum = "4b45fcc2344c680f5025fe57779faef368840d0bd1f42f216291f0dc4ace4744" dependencies = [ - "bitflags 2.10.0", + "bitflags 2.11.1", "num-traits", - "rand 0.9.2", + "rand 0.9.4", "rand_chacha 0.9.0", "rand_xorshift", "regex-syntax", @@ -5334,7 +5561,7 @@ checksum = "22505a5c94da8e3b7c2996394d1c933236c4d743e81a410bcca4e6989fc066a4" dependencies = [ "bytes", "heck 0.5.0", - "itertools 0.10.5", + "itertools 0.12.1", "log", "multimap", "once_cell", @@ -5354,7 +5581,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "81bddcdb20abf9501610992b6759a4c888aef7d1a7247ef75e2404275ac24af1" dependencies = [ "anyhow", - "itertools 0.10.5", + "itertools 0.12.1", "proc-macro2", "quote", "syn 2.0.117", @@ -5388,7 +5615,7 @@ version = "0.9.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "57206b407293d2bcd3af849ce869d52068623f19e1b5ff8e8778e3309439682b" dependencies = [ - "bitflags 2.10.0", + "bitflags 2.11.1", "getopts", "memchr", "unicase", @@ -5396,11 +5623,11 @@ dependencies = [ [[package]] name = "pulldown-cmark" -version = "0.13.0" +version = "0.13.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e8bbe1a966bd2f362681a44f6edce3c2310ac21e4d5067a6e7ec396297a6ea0" +checksum = "7c3a14896dfa883796f1cb410461aef38810ea05f2b2c33c5aded3649095fdad" dependencies = [ - "bitflags 2.10.0", + "bitflags 2.11.1", "memchr", "pulldown-cmark-escape", "unicase", @@ -5414,12 +5641,9 @@ checksum = "007d8adb5ddab6f8e3f491ac63566a7d5002cc7ed73901f72057943fa71ae1ae" [[package]] name = "pxfm" -version = "0.1.20" +version = "0.1.29" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6e790881194f6f6e86945f0a42a6981977323669aeb6c40e9c7ec253133b96f8" -dependencies = [ - "num-traits", -] +checksum = "e0c5ccf5294c6ccd63a74f1565028353830a9c2f5eb0c682c355c471726a6e3f" [[package]] name = "qrcode" @@ -5441,9 +5665,9 @@ dependencies = [ "pin-project-lite", "quinn-proto", "quinn-udp", - "rustc-hash 2.0.0", - "rustls 0.23.38", - "socket2 0.6.0", + "rustc-hash 2.1.2", + "rustls 0.23.40", + "socket2", "thiserror 2.0.18", "tokio", "tracing", @@ -5460,10 +5684,10 @@ dependencies = [ "bytes", "getrandom 0.3.4", "lru-slab", - "rand 0.9.2", + "rand 0.9.4", "ring", - "rustc-hash 2.0.0", - "rustls 0.23.38", + "rustc-hash 2.1.2", + "rustls 0.23.40", "rustls-pki-types", "slab", "thiserror 2.0.18", @@ -5474,22 +5698,23 @@ dependencies = [ [[package]] name = "quinn-udp" -version = "0.5.3" +version = "0.5.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "25a78e6f726d84fcf960409f509ae354a32648f090c8d32a2ea8b1a1bc3bab14" +checksum = "addec6a0dcad8a8d96a771f815f0eaf55f9d1805756410b39f5fa81332574cbd" dependencies = [ + "cfg_aliases", "libc", "once_cell", - "socket2 0.5.7", + "socket2", "tracing", - "windows-sys 0.52.0", + "windows-sys 0.60.2", ] [[package]] name = "quote" -version = "1.0.37" +version = "1.0.45" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af" +checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" dependencies = [ "proc-macro2", ] @@ -5508,9 +5733,9 @@ checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" [[package]] name = "rand" -version = "0.8.5" +version = "0.8.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" +checksum = "5ca0ecfa931c29007047d1bc58e623ab12e5590e8c7cc53200d5202b69266d8a" dependencies = [ "libc", "rand_chacha 0.3.1", @@ -5519,12 +5744,12 @@ dependencies = [ [[package]] name = "rand" -version = "0.9.2" +version = "0.9.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1" +checksum = "44c5af06bb1b7d3216d91932aed5265164bf384dc89cd6ba05cf59a35f5f76ea" dependencies = [ "rand_chacha 0.9.0", - "rand_core 0.9.3", + "rand_core 0.9.5", ] [[package]] @@ -5535,7 +5760,7 @@ checksum = "d2e8e8bcc7961af1fdac401278c6a831614941f6164ee3bf4ce61b7edb162207" dependencies = [ "chacha20 0.10.0", "getrandom 0.4.2", - "rand_core 0.10.0", + "rand_core 0.10.1", ] [[package]] @@ -5555,7 +5780,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb" dependencies = [ "ppv-lite86", - "rand_core 0.9.3", + "rand_core 0.9.5", ] [[package]] @@ -5564,23 +5789,23 @@ version = "0.6.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" dependencies = [ - "getrandom 0.2.15", + "getrandom 0.2.17", ] [[package]] name = "rand_core" -version = "0.9.3" +version = "0.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38" +checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c" dependencies = [ "getrandom 0.3.4", ] [[package]] name = "rand_core" -version = "0.10.0" +version = "0.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c8d0fd677905edcbeedbf2edb6494d676f0e98d54d5cf9bda0b061cb8fb8aba" +checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69" [[package]] name = "rand_distr" @@ -5589,7 +5814,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "32cb0b9bc82b0a0876c2dd994a7e7a2683d3e7390ca40e6886785ef0c7e3ee31" dependencies = [ "num-traits", - "rand 0.8.5", + "rand 0.8.6", ] [[package]] @@ -5598,7 +5823,7 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "513962919efc330f829edb2535844d1b912b0fbe2ca165d613e4e8788bb05a5a" dependencies = [ - "rand_core 0.9.3", + "rand_core 0.9.5", ] [[package]] @@ -5607,7 +5832,7 @@ version = "0.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f703f4665700daf5512dcca5f43afa6af89f09db47fb56be587f80636bda2d41" dependencies = [ - "rand_core 0.9.3", + "rand_core 0.9.5", ] [[package]] @@ -5616,7 +5841,7 @@ version = "0.29.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "eabd94c2f37801c20583fc49dd5cd6b0ba68c716787c2dd6ed18571e1e63117b" dependencies = [ - "bitflags 2.10.0", + "bitflags 2.11.1", "cassowary", "compact_str", "crossterm", @@ -5633,9 +5858,9 @@ dependencies = [ [[package]] name = "rayon" -version = "1.10.0" +version = "1.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa" +checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d" dependencies = [ "either", "rayon-core", @@ -5643,9 +5868,9 @@ dependencies = [ [[package]] name = "rayon-core" -version = "1.12.1" +version = "1.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2" +checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91" dependencies = [ "crossbeam-deque", "crossbeam-utils", @@ -5653,44 +5878,44 @@ dependencies = [ [[package]] name = "readlock" -version = "0.1.8" +version = "0.1.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "072cfe5b1d2dcd38d20e18f85e9c9978b6cc08f0b373e9f1fff1541335622974" +checksum = "6da6f291b23556edd9edaf655a0be2ad8ef8002ff5f1bca62b264f3f58b53f34" [[package]] name = "readlock-tokio" -version = "0.1.3" +version = "0.1.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "867fac64d07214a87e5cf4e88b4ce855844a1cea243534392377d1ac2c911653" +checksum = "fc7e264f9ec4f3d112e8e2f214e8e7cb5cf3b83278f3570b7e00bfe13d3bd8ff" dependencies = [ "tokio", ] [[package]] name = "redox_syscall" -version = "0.5.3" +version = "0.5.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2a908a6e00f1fdd0dfd9c0eb08ce85126f6d8bbda50017e74bc4a4b7d4a926a4" +checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d" dependencies = [ - "bitflags 2.10.0", + "bitflags 2.11.1", ] [[package]] name = "redox_users" -version = "0.5.0" +version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dd6f9d3d47bdd2ad6945c5015a226ec6155d0bcdfd8f7cd29f86b71f8de99d2b" +checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac" dependencies = [ - "getrandom 0.2.15", + "getrandom 0.2.17", "libredox", "thiserror 2.0.18", ] [[package]] name = "regex" -version = "1.12.2" +version = "1.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4" +checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276" dependencies = [ "aho-corasick", "memchr", @@ -5700,9 +5925,9 @@ dependencies = [ [[package]] name = "regex-automata" -version = "0.4.13" +version = "0.4.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c" +checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f" dependencies = [ "aho-corasick", "memchr", @@ -5711,9 +5936,9 @@ dependencies = [ [[package]] name = "regex-syntax" -version = "0.8.5" +version = "0.8.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c" +checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a" [[package]] name = "reqwest" @@ -5728,7 +5953,7 @@ dependencies = [ "futures-core", "futures-util", "h2", - "http 1.3.1", + "http 1.4.0", "http-body", "http-body-util", "hyper", @@ -5742,7 +5967,7 @@ dependencies = [ "percent-encoding", "pin-project-lite", "quinn", - "rustls 0.23.38", + "rustls 0.23.40", "rustls-native-certs 0.8.3", "rustls-pki-types", "serde", @@ -5751,7 +5976,7 @@ dependencies = [ "sync_wrapper", "tokio", "tokio-native-tls", - "tokio-rustls 0.26.0", + "tokio-rustls 0.26.4", "tower", "tower-http", "tower-service", @@ -5763,9 +5988,9 @@ dependencies = [ [[package]] name = "reqwest" -version = "0.13.2" +version = "0.13.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ab3f43e3283ab1488b624b44b0e988d0acea0b3214e694730a055cb6b2efa801" +checksum = "62e0021ea2c22aed41653bc7e1419abb2c97e038ff2c33d0e1309e49a97deec0" dependencies = [ "base64 0.22.1", "bytes", @@ -5773,7 +5998,7 @@ dependencies = [ "futures-core", "futures-util", "h2", - "http 1.3.1", + "http 1.4.0", "http-body", "http-body-util", "hyper", @@ -5786,15 +6011,15 @@ dependencies = [ "percent-encoding", "pin-project-lite", "quinn", - "rustls 0.23.38", + "rustls 0.23.40", "rustls-pki-types", - "rustls-platform-verifier", + "rustls-platform-verifier 0.7.0", "serde", "serde_json", "sync_wrapper", "tokio", "tokio-native-tls", - "tokio-rustls 0.26.0", + "tokio-rustls 0.26.4", "tokio-util", "tower", "tower-http", @@ -5814,7 +6039,7 @@ checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7" dependencies = [ "cc", "cfg-if", - "getrandom 0.2.15", + "getrandom 0.2.17", "libc", "untrusted", "windows-sys 0.52.0", @@ -5822,45 +6047,42 @@ dependencies = [ [[package]] name = "rmp" -version = "0.8.14" +version = "0.8.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "228ed7c16fa39782c3b3468e974aec2795e9089153cd08ee2e9aefb3613334c4" +checksum = "4ba8be72d372b2c9b35542551678538b562e7cf86c3315773cae48dfbfe7790c" dependencies = [ - "byteorder", "num-traits", - "paste", ] [[package]] name = "rmp-serde" -version = "1.3.0" +version = "1.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "52e599a477cf9840e92f2cde9a7189e67b42c57532749bf90aea6ec10facd4db" +checksum = "72f81bee8c8ef9b577d1681a70ebbc962c232461e397b22c208c43c04b67a155" dependencies = [ - "byteorder", "rmp", "serde", ] [[package]] name = "rpassword" -version = "7.4.0" +version = "7.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "66d4c8b64f049c6721ec8ccec37ddfc3d641c4a7fca57e8f2a89de509c73df39" +checksum = "5ac5b223d9738ef56e0b98305410be40fa0941bf6036c56f1506751e43552d64" dependencies = [ "libc", "rtoolbox", - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] name = "rtoolbox" -version = "0.0.2" +version = "0.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c247d24e63230cdb56463ae328478bd5eac8b8faa8c69461a77e8e323afac90e" +checksum = "50a0e551c1e27e1731aba276dbeaeac73f53c7cd34d1bda485d02bd1e0f36844" dependencies = [ "libc", - "windows-sys 0.48.0", + "windows-sys 0.59.0", ] [[package]] @@ -5891,7 +6113,7 @@ dependencies = [ "as_variant", "assign", "bytes", - "http 1.3.1", + "http 1.4.0", "js_int", "js_option", "maplit", @@ -5917,7 +6139,7 @@ dependencies = [ "date_header", "form_urlencoded", "getrandom 0.4.2", - "http 1.3.1", + "http 1.4.0", "indexmap", "js_int", "konst", @@ -5950,7 +6172,7 @@ dependencies = [ "js_int", "js_option", "language-tags", - "pulldown-cmark 0.13.0", + "pulldown-cmark 0.13.3", "ruma-common", "ruma-html", "ruma-macros", @@ -5970,7 +6192,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "06ebea8616d3d3cc26057f7856b9ef42aba1e37c44d2c136856134f3083a44ef" dependencies = [ "headers", - "http 1.3.1", + "http 1.4.0", "http-auth", "httparse", "js_int", @@ -6046,7 +6268,7 @@ version = "0.37.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "165ca6e57b20e1351573e3729b958bc62f0e48025386970b6e4d29e7a7e71f3f" dependencies = [ - "bitflags 2.10.0", + "bitflags 2.11.1", "fallible-iterator", "fallible-streaming-iterator", "hashlink", @@ -6066,9 +6288,9 @@ dependencies = [ [[package]] name = "rustc-demangle" -version = "0.1.24" +version = "0.1.27" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f" +checksum = "b50b8869d9fc858ce7266cce0194bd74df58b9d0e3f6df3a9fc8eb470d95c09d" [[package]] name = "rustc-hash" @@ -6078,43 +6300,43 @@ checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" [[package]] name = "rustc-hash" -version = "2.0.0" +version = "2.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "583034fd73374156e66797ed8e5b0d5690409c9226b22d87cb7f19821c05d152" +checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe" [[package]] name = "rustc_version" -version = "0.4.0" +version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366" +checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92" dependencies = [ "semver", ] [[package]] name = "rustix" -version = "0.38.41" +version = "0.38.44" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d7f649912bc1495e167a6edee79151c84b1bad49748cb4f1f1167f459f6224f6" +checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154" dependencies = [ - "bitflags 2.10.0", + "bitflags 2.11.1", "errno", "libc", - "linux-raw-sys 0.4.14", - "windows-sys 0.52.0", + "linux-raw-sys 0.4.15", + "windows-sys 0.59.0", ] [[package]] name = "rustix" -version = "1.0.8" +version = "1.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "11181fbabf243db407ef8df94a6ce0b2f9a733bd8be4ad02b4eda9602296cac8" +checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190" dependencies = [ - "bitflags 2.10.0", + "bitflags 2.11.1", "errno", "libc", - "linux-raw-sys 0.9.4", - "windows-sys 0.60.2", + "linux-raw-sys 0.12.1", + "windows-sys 0.61.2", ] [[package]] @@ -6131,9 +6353,9 @@ dependencies = [ [[package]] name = "rustls" -version = "0.23.38" +version = "0.23.40" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "69f9466fb2c14ea04357e91413efb882e2a6d4a406e625449bc0a5d360d53a21" +checksum = "ef86cd5876211988985292b91c96a8f2d298df24e75989a43a3c73f2d4d8168b" dependencies = [ "aws-lc-rs", "log", @@ -6152,20 +6374,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a9aace74cb666635c918e9c12bc0d348266037aa8eb599b5cba565709a8dff00" dependencies = [ "openssl-probe 0.1.6", - "rustls-pemfile 1.0.4", - "schannel", - "security-framework 2.11.1", -] - -[[package]] -name = "rustls-native-certs" -version = "0.7.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e5bfb394eeed242e909609f56089eecfe5fda225042e8b171791b9c95f5931e5" -dependencies = [ - "openssl-probe 0.1.6", - "rustls-pemfile 2.2.0", - "rustls-pki-types", + "rustls-pemfile", "schannel", "security-framework 2.11.1", ] @@ -6176,10 +6385,10 @@ version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "612460d5f7bea540c490b2b6395d8e34a953e52b491accd6c86c8164c5932a63" dependencies = [ - "openssl-probe 0.2.0", + "openssl-probe 0.2.1", "rustls-pki-types", "schannel", - "security-framework 3.5.1", + "security-framework 3.7.0", ] [[package]] @@ -6192,40 +6401,52 @@ dependencies = [ ] [[package]] -name = "rustls-pemfile" -version = "2.2.0" +name = "rustls-pki-types" +version = "1.14.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dce314e5fee3f39953d46bb63bb8a46d40c2f8fb7cc5a3b6cab2bde9721d6e50" +checksum = "30a7197ae7eb376e574fe940d068c30fe0462554a3ddbe4eca7838e049c937a9" dependencies = [ - "rustls-pki-types", + "web-time", + "zeroize", ] [[package]] -name = "rustls-pki-types" -version = "1.14.0" +name = "rustls-platform-verifier" +version = "0.6.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "be040f8b0a225e40375822a563fa9524378b9d63112f53e19ffff34df5d33fdd" +checksum = "1d99feebc72bae7ab76ba994bb5e121b8d83d910ca40b36e0921f53becc41784" dependencies = [ - "web-time", - "zeroize", + "core-foundation 0.10.1", + "core-foundation-sys", + "jni 0.21.1", + "log", + "once_cell", + "rustls 0.23.40", + "rustls-native-certs 0.8.3", + "rustls-platform-verifier-android", + "rustls-webpki 0.103.13", + "security-framework 3.7.0", + "security-framework-sys", + "webpki-root-certs", + "windows-sys 0.61.2", ] [[package]] name = "rustls-platform-verifier" -version = "0.6.2" +version = "0.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1d99feebc72bae7ab76ba994bb5e121b8d83d910ca40b36e0921f53becc41784" +checksum = "26d1e2536ce4f35f4846aa13bff16bd0ff40157cdb14cc056c7b14ba41233ba0" dependencies = [ "core-foundation 0.10.1", "core-foundation-sys", - "jni", + "jni 0.22.4", "log", "once_cell", - "rustls 0.23.38", + "rustls 0.23.40", "rustls-native-certs 0.8.3", "rustls-platform-verifier-android", "rustls-webpki 0.103.13", - "security-framework 3.5.1", + "security-framework 3.7.0", "security-framework-sys", "webpki-root-certs", "windows-sys 0.61.2", @@ -6267,9 +6488,9 @@ checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" [[package]] name = "ryu" -version = "1.0.18" +version = "1.0.23" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f" +checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f" [[package]] name = "same-file" @@ -6318,9 +6539,9 @@ dependencies = [ [[package]] name = "scroll_derive" -version = "0.12.0" +version = "0.12.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f81c2fde025af7e69b1d1420531c8a8811ca898919db177141a85313b1cb932" +checksum = "1783eabc414609e28a5ba76aee5ddd52199f7107a0b24c2e9746a1ecc34a683d" dependencies = [ "proc-macro2", "quote", @@ -6354,7 +6575,7 @@ version = "2.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02" dependencies = [ - "bitflags 2.10.0", + "bitflags 2.11.1", "core-foundation 0.9.4", "core-foundation-sys", "libc", @@ -6363,11 +6584,11 @@ dependencies = [ [[package]] name = "security-framework" -version = "3.5.1" +version = "3.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b3297343eaf830f66ede390ea39da1d462b6b0c1b000f420d0a83f898bbbe6ef" +checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d" dependencies = [ - "bitflags 2.10.0", + "bitflags 2.11.1", "core-foundation 0.10.1", "core-foundation-sys", "libc", @@ -6376,9 +6597,9 @@ dependencies = [ [[package]] name = "security-framework-sys" -version = "2.15.0" +version = "2.17.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cc1f0cbffaac4852523ce30d8bd3c5cdc873501d96ff467ca09b6767bb8cd5c0" +checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3" dependencies = [ "core-foundation-sys", "libc", @@ -6386,9 +6607,9 @@ dependencies = [ [[package]] name = "semver" -version = "1.0.27" +version = "1.0.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2" +checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd" dependencies = [ "serde", "serde_core", @@ -6402,7 +6623,7 @@ checksum = "eb25f439f97d26fea01d717fa626167ceffcd981addaa670001e70505b72acbb" dependencies = [ "cfg_aliases", "httpdate", - "reqwest 0.13.2", + "reqwest 0.13.3", "sentry-backtrace", "sentry-contexts", "sentry-core", @@ -6443,7 +6664,7 @@ version = "0.47.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0ac170a5bba8bec6e3339c90432569d89641fa7a3d3e4f44987d24f0762e6adf" dependencies = [ - "rand 0.9.2", + "rand 0.9.4", "sentry-types", "serde", "serde_json", @@ -6476,7 +6697,7 @@ version = "0.47.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "27701acc51e68db5281802b709010395bfcbcb128b1d0a4e5873680d3b47ff0c" dependencies = [ - "bitflags 2.10.0", + "bitflags 2.11.1", "sentry-backtrace", "sentry-core", "tracing-core", @@ -6491,7 +6712,7 @@ checksum = "56780cb5597d676bf22e6c11d1f062eb4def46390ea3bfb047bcbcf7dfd19bdb" dependencies = [ "debugid", "hex", - "rand 0.9.2", + "rand 0.9.4", "serde", "serde_json", "thiserror 2.0.18", @@ -6566,15 +6787,15 @@ dependencies = [ [[package]] name = "serde_json" -version = "1.0.145" +version = "1.0.149" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "402a6f66d8c709116cf22f558eab210f5a50187f702eb4d7e5ef38d9a7f1c79c" +checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86" dependencies = [ "itoa", "memchr", - "ryu", "serde", "serde_core", + "zmij", ] [[package]] @@ -6616,7 +6837,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba" dependencies = [ "cfg-if", - "cpufeatures 0.2.12", + "cpufeatures 0.2.17", "digest", ] @@ -6627,7 +6848,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283" dependencies = [ "cfg-if", - "cpufeatures 0.2.12", + "cpufeatures 0.2.17", "digest", ] @@ -6648,9 +6869,9 @@ checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" [[package]] name = "signal-hook" -version = "0.3.17" +version = "0.3.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8621587d4798caf8eb44879d42e56b9a93ea5dcd315a6487c357130095b62801" +checksum = "d881a16cf4426aa584979d30bd82cb33429027e42122b169753d6ef1085ed6e2" dependencies = [ "libc", "signal-hook-registry", @@ -6658,9 +6879,9 @@ dependencies = [ [[package]] name = "signal-hook-mio" -version = "0.2.4" +version = "0.2.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "34db1a06d485c9142248b7a054f034b349b212551f3dfd19c94d45a754a217cd" +checksum = "b75a19a7a740b25bc7944bdee6172368f988763b744e3d4dfe753f6b4ece40cc" dependencies = [ "libc", "mio", @@ -6669,10 +6890,11 @@ dependencies = [ [[package]] name = "signal-hook-registry" -version = "1.4.2" +version = "1.4.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a9e9e0b4211b72e7b8b6e85c807d36c212bdb33ea8587f7569562a84df5465b1" +checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b" dependencies = [ + "errno", "libc", ] @@ -6687,15 +6909,31 @@ dependencies = [ [[package]] name = "simd-adler32" -version = "0.3.7" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "703d5c7ef118737c72f1af64ad2f6f8c5e1921f818cdcb97b8fe6fc69bf66214" + +[[package]] +name = "simd_cesu8" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94f90157bb87cddf702797c5dadfa0be7d266cdf49e22da2fcaa32eff75b2c33" +dependencies = [ + "rustc_version", + "simdutf8", +] + +[[package]] +name = "simdutf8" +version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe" +checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e" [[package]] name = "similar" -version = "2.6.0" +version = "2.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1de1d4f81173b03af4c0cbed3c898f6bff5b870e4a7f5d6f4057d62a7a4b686e" +checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa" [[package]] name = "similar-asserts" @@ -6703,33 +6941,30 @@ version = "1.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b5b441962c817e33508847a22bd82f03a30cff43642dc2fae8b050566121eb9a" dependencies = [ - "console", + "console 0.15.11", "similar", ] [[package]] name = "siphasher" -version = "1.0.1" +version = "1.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d" +checksum = "8ee5873ec9cce0195efcb7a4e9507a04cd49aec9c83d0389df45b1ef7ba2e649" [[package]] name = "sketches-ddsketch" -version = "0.3.0" +version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c1e9a774a6c28142ac54bb25d25562e6bcf957493a184f15ad4eebccb23e410a" +checksum = "0c6f73aeb92d671e0cc4dca167e59b2deb6387c375391bc99ee743f326994a2b" dependencies = [ "serde", ] [[package]] name = "slab" -version = "0.4.9" +version = "0.4.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67" -dependencies = [ - "autocfg", -] +checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" [[package]] name = "smallvec" @@ -6748,22 +6983,12 @@ checksum = "b7c388c1b5e93756d0c740965c41e8822f866621d41acbdf6336a6a168f8840c" [[package]] name = "socket2" -version = "0.5.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce305eb0b4296696835b71df73eb912e0f1ffd2556a501fcede6e0c50349191c" -dependencies = [ - "libc", - "windows-sys 0.52.0", -] - -[[package]] -name = "socket2" -version = "0.6.0" +version = "0.6.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "233504af464074f9d066d7b5416c5f9b894a5862a6506e306f7b816cdd6f1807" +checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e" dependencies = [ "libc", - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] @@ -6778,9 +7003,9 @@ dependencies = [ [[package]] name = "stable_deref_trait" -version = "1.2.0" +version = "1.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" +checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596" [[package]] name = "static_assertions" @@ -6852,7 +7077,7 @@ version = "0.27.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf" dependencies = [ - "strum_macros 0.27.1", + "strum_macros 0.27.2", ] [[package]] @@ -6870,14 +7095,13 @@ dependencies = [ [[package]] name = "strum_macros" -version = "0.27.1" +version = "0.27.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c77a8c5abcaf0f9ce05d62342b7d298c346515365c36b673df4ebe3ced01fde8" +checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7" dependencies = [ "heck 0.5.0", "proc-macro2", "quote", - "rustversion", "syn 2.0.117", ] @@ -6911,18 +7135,18 @@ dependencies = [ [[package]] name = "sync_wrapper" -version = "1.0.1" +version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a7065abeca94b6a8a577f9bd45aa0867a2238b74e8eb67cf10d492bc39351394" +checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263" dependencies = [ "futures-core", ] [[package]] name = "synstructure" -version = "0.13.1" +version = "0.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971" +checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" dependencies = [ "proc-macro2", "quote", @@ -6931,11 +7155,11 @@ dependencies = [ [[package]] name = "system-configuration" -version = "0.6.1" +version = "0.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3c879d448e9d986b661742763247d3693ed13609438cf3d006f51f5368a5ba6b" +checksum = "a13f3d0daba03132c0aa9767f98351b3488edc2c100cda2d2ec2b04f3d8d3c8b" dependencies = [ - "bitflags 2.10.0", + "bitflags 2.11.1", "core-foundation 0.9.4", "system-configuration-sys", ] @@ -6952,14 +7176,14 @@ dependencies = [ [[package]] name = "system-deps" -version = "7.0.7" +version = "7.0.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "48c8f33736f986f16d69b6cb8b03f55ddcad5c41acc4ccc39dd88e84aa805e7f" +checksum = "396a35feb67335377e0251fcbc1092fc85c484bd4e3a7a54319399da127796e7" dependencies = [ "cfg-expr", "heck 0.5.0", "pkg-config", - "toml 0.9.7", + "toml 1.1.2+spec-1.1.0", "version-compare", ] @@ -6996,7 +7220,7 @@ dependencies = [ "rayon", "regex", "rust-stemmers", - "rustc-hash 2.0.0", + "rustc-hash 2.1.2", "serde", "serde_json", "sketches-ddsketch", @@ -7117,14 +7341,14 @@ checksum = "df7f62577c25e07834649fc3b39fafdc597c0a3527dc1c60129201ccfcbaa50c" [[package]] name = "tempfile" -version = "3.23.0" +version = "3.27.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2d31c77bdf42a745371d260a26ca7163f1e0924b64afa0b688e61b5a9fa02f16" +checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd" dependencies = [ "fastrand", - "getrandom 0.3.4", + "getrandom 0.4.2", "once_cell", - "rustix 1.0.8", + "rustix 1.1.4", "windows-sys 0.61.2", ] @@ -7160,11 +7384,11 @@ dependencies = [ [[package]] name = "thiserror" -version = "1.0.63" +version = "1.0.69" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c0342370b38b6a11b6cc11d6a805569958d54cfa061a29969c3b5ce2ea405724" +checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" dependencies = [ - "thiserror-impl 1.0.63", + "thiserror-impl 1.0.69", ] [[package]] @@ -7178,9 +7402,9 @@ dependencies = [ [[package]] name = "thiserror-impl" -version = "1.0.63" +version = "1.0.69" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a4558b58466b9ad7ca0f102865eccc95938dca1a74a856f2b57b6629050da261" +checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" dependencies = [ "proc-macro2", "quote", @@ -7200,12 +7424,11 @@ dependencies = [ [[package]] name = "thread_local" -version = "1.1.8" +version = "1.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c" +checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185" dependencies = [ "cfg-if", - "once_cell", ] [[package]] @@ -7252,9 +7475,9 @@ dependencies = [ [[package]] name = "tinystr" -version = "0.7.6" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9117f5d4db391c1cf6927e7bea3db74b9a1c1add8f7eda9ffd5364f40f57b82f" +checksum = "c8323304221c2a851516f22236c5722a72eaa19749016521d6dff0824447d96d" dependencies = [ "displaydoc", "zerovec", @@ -7272,9 +7495,9 @@ dependencies = [ [[package]] name = "tinyvec" -version = "1.8.0" +version = "1.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "445e881f4f6d382d5f27c034e25eb92edd7c784ceab92a0937db7f2e9471b938" +checksum = "3e61e67053d25a4e82c844e8424039d9745781b3fc4f32b8d55ed50f5f667ef3" dependencies = [ "tinyvec_macros", ] @@ -7287,9 +7510,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" [[package]] name = "tokio" -version = "1.48.0" +version = "1.52.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ff360e02eab121e0bc37a2d3b4d4dc622e6eda3a8e5253d5435ecf5bd4c68408" +checksum = "8fc7f01b389ac15039e4dc9531aa973a135d7a4135281b12d7c1bc79fd57fffe" dependencies = [ "bytes", "libc", @@ -7297,16 +7520,16 @@ dependencies = [ "parking_lot", "pin-project-lite", "signal-hook-registry", - "socket2 0.6.0", + "socket2", "tokio-macros", "windows-sys 0.61.2", ] [[package]] name = "tokio-macros" -version = "2.6.0" +version = "2.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5" +checksum = "385a6cb71ab9ab790c5fe8d67f1645e6c450a7ce006a33de03daa956cf70a496" dependencies = [ "proc-macro2", "quote", @@ -7335,20 +7558,19 @@ dependencies = [ [[package]] name = "tokio-rustls" -version = "0.26.0" +version = "0.26.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c7bc40d0e5a97695bb96e27995cd3a08538541b0a846f65bba7a359f36700d4" +checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61" dependencies = [ - "rustls 0.23.38", - "rustls-pki-types", + "rustls 0.23.40", "tokio", ] [[package]] name = "tokio-stream" -version = "0.1.17" +version = "0.1.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eca58d7bba4a75707817a2c44174253f9236b2d5fbd055602e9d5c07c139a047" +checksum = "32da49809aab5c3bc678af03902d4ccddea2a87d028d86392a4b1560c6906c70" dependencies = [ "futures-core", "pin-project-lite", @@ -7358,12 +7580,10 @@ dependencies = [ [[package]] name = "tokio-test" -version = "0.4.4" +version = "0.4.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2468baabc3311435b55dd935f702f42cd1b8abb7e754fb7dfb16bd36aa88f9f7" +checksum = "3f6d24790a10a7af737693a3e8f1d03faef7e6ca0cc99aae5066f533766de545" dependencies = [ - "async-stream", - "bytes", "futures-core", "tokio", "tokio-stream", @@ -7388,9 +7608,9 @@ dependencies = [ [[package]] name = "tokio-util" -version = "0.7.17" +version = "0.7.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2efa149fe76073d6e8fd97ef4f4eca7b67f599660115591483572e406e165594" +checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098" dependencies = [ "bytes", "futures-core", @@ -7402,17 +7622,17 @@ dependencies = [ [[package]] name = "toml" -version = "0.9.7" +version = "0.9.12+spec-1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "00e5e5d9bf2475ac9d4f0d9edab68cc573dc2fd644b0dba36b0c30a92dd9eaa0" +checksum = "cf92845e79fc2e2def6a5d828f0801e29a2f8acc037becc5ab08595c7d5e9863" dependencies = [ "indexmap", "serde_core", "serde_spanned", - "toml_datetime 0.7.2", + "toml_datetime 0.7.5+spec-1.1.0", "toml_parser", "toml_writer", - "winnow 0.7.13", + "winnow 0.7.15", ] [[package]] @@ -7421,18 +7641,20 @@ version = "1.1.2+spec-1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "81f3d15e84cbcd896376e6730314d59fb5a87f31e4b038454184435cd57defee" dependencies = [ + "indexmap", "serde_core", "serde_spanned", "toml_datetime 1.1.1+spec-1.1.0", "toml_parser", - "winnow 1.0.1", + "toml_writer", + "winnow 1.0.2", ] [[package]] name = "toml_datetime" -version = "0.7.2" +version = "0.7.5+spec-1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "32f1085dec27c2b6632b04c80b3bb1b4300d6495d1e129693bdda7d91e72eec1" +checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347" dependencies = [ "serde_core", ] @@ -7448,14 +7670,14 @@ dependencies = [ [[package]] name = "toml_edit" -version = "0.25.6+spec-1.1.0" +version = "0.25.11+spec-1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0db3bae107c9522f86d361697dee1d7386a2ddcf659d5aea5159819a21a3c4a7" +checksum = "0b59c4d22ed448339746c59b905d24568fcbb3ab65a500494f7b8c3e97739f2b" dependencies = [ "indexmap", "toml_datetime 1.1.1+spec-1.1.0", "toml_parser", - "winnow 1.0.1", + "winnow 1.0.2", ] [[package]] @@ -7464,20 +7686,20 @@ version = "1.1.2+spec-1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a2abe9b86193656635d2411dc43050282ca48aa31c2451210f4202550afb7526" dependencies = [ - "winnow 1.0.1", + "winnow 1.0.2", ] [[package]] name = "toml_writer" -version = "1.0.4" +version = "1.1.1+spec-1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "df8b2b54733674ad286d16267dcfc7a71ed5c776e4ac7aa3c3e2561f7c637bf2" +checksum = "756daf9b1013ebe47a8776667b466417e2d4c5679d441c26230efd9ef78692db" [[package]] name = "tower" -version = "0.5.2" +version = "0.5.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d039ad9159c98b70ecfd540b2573b97f7f52c3e8d9f8ad57a24b916a536975f9" +checksum = "ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4" dependencies = [ "futures-core", "futures-util", @@ -7491,25 +7713,25 @@ dependencies = [ [[package]] name = "tower-http" -version = "0.6.8" +version = "0.6.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8" +checksum = "68d6fdd9f81c2819c9a8b0e0cd91660e7746a8e6ea2ba7c6b2b057985f6bcb51" dependencies = [ "async-compression", - "bitflags 2.10.0", + "bitflags 2.11.1", "bytes", "futures-core", "futures-util", - "http 1.3.1", + "http 1.4.0", "http-body", "http-body-util", - "iri-string", "pin-project-lite", "tokio", "tokio-util", "tower", "tower-layer", "tower-service", + "url", ] [[package]] @@ -7567,9 +7789,9 @@ dependencies = [ [[package]] name = "tracing-error" -version = "0.2.0" +version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d686ec1c0f384b1277f097b2f279a2ecc11afe8c133c1aabf036a27cb4cd206e" +checksum = "8b1581020d7a273442f5b45074a6a57d5757ad0a47dac0e9f0bd57b81936f3db" dependencies = [ "tracing", "tracing-subscriber", @@ -7614,7 +7836,7 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "743912880bcd21d1034063a1b5c6630d444d5a6cc9f90e2c0a200bbe278907c7" dependencies = [ - "bitflags 2.10.0", + "bitflags 2.11.1", "crossterm", "derive_builder", "itertools 0.14.0", @@ -7636,9 +7858,9 @@ dependencies = [ [[package]] name = "tui-widget-list" -version = "0.13.2" +version = "0.13.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a417c8ac65119a0e5b8627d0ce492731b95affb29ec8602d9e72646bda5ecf6" +checksum = "80da7b26879a0c8f183d263808dff987a764c01333e46ba16a8c85c6a90a6769" dependencies = [ "ratatui", ] @@ -7656,10 +7878,10 @@ dependencies = [ "httparse", "log", "native-tls", - "rand 0.8.5", + "rand 0.8.6", "rustls 0.21.12", "sha1", - "thiserror 1.0.63", + "thiserror 1.0.69", "url", "utf-8", ] @@ -7673,28 +7895,28 @@ dependencies = [ "byteorder", "bytes", "data-encoding", - "http 1.3.1", + "http 1.4.0", "httparse", "log", "native-tls", - "rand 0.8.5", + "rand 0.8.6", "sha1", - "thiserror 1.0.63", + "thiserror 1.0.69", "url", "utf-8", ] [[package]] name = "typenum" -version = "1.17.0" +version = "1.20.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825" +checksum = "40ce102ab67701b8526c123c1bab5cbe42d7040ccfd0f64af1a385808d2f43de" [[package]] name = "typewit" -version = "1.14.2" +version = "1.15.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8c1ae7cc0fdb8b842d65d127cb981574b0d2b249b74d1c7a2986863dc134f71" +checksum = "214ca0b2191785cbc06209b9ca1861e048e39b5ba33574b3cedd58363d5bb5f6" [[package]] name = "ucd-trie" @@ -7704,11 +7926,11 @@ checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971" [[package]] name = "ulid" -version = "1.1.4" +version = "1.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f294bff79170ed1c5633812aff1e565c35d993a36e757f9bc0accf5eec4e6045" +checksum = "470dbf6591da1b39d43c14523b2b469c86879a53e8b758c8e090a470fe7b1fbe" dependencies = [ - "rand 0.8.5", + "rand 0.9.4", "web-time", ] @@ -7729,18 +7951,15 @@ checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94" [[package]] name = "unicase" -version = "2.7.0" +version = "2.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f7d2d4dafb69621809a81864c9c1b864479e1235c0dd4e199924b9742439ed89" -dependencies = [ - "version_check", -] +checksum = "dbc4bc3a9f746d862c45cb89d705aa10f187bb96c76001afab07a0d35ce60142" [[package]] name = "unicode-ident" -version = "1.0.22" +version = "1.0.24" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" [[package]] name = "unicode-linebreak" @@ -7759,9 +7978,9 @@ dependencies = [ [[package]] name = "unicode-segmentation" -version = "1.12.0" +version = "1.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493" +checksum = "9629274872b2bfaf8d66f5f15725007f635594914870f65218920345aa11aa8c" [[package]] name = "unicode-truncate" @@ -7771,14 +7990,14 @@ checksum = "b3644627a5af5fa321c95b9b235a72fd24cd29c648c2c379431e6628655627bf" dependencies = [ "itertools 0.13.0", "unicode-segmentation", - "unicode-width 0.1.13", + "unicode-width 0.1.14", ] [[package]] name = "unicode-width" -version = "0.1.13" +version = "0.1.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0336d538f7abc86d282a4189614dfaa90810dfc2c6f6427eaf88e16311dd225d" +checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af" [[package]] name = "unicode-width" @@ -7794,9 +8013,9 @@ checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853" [[package]] name = "uniffi" -version = "0.31.0" +version = "0.31.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b8c6dec3fc6645f71a16a3fa9ff57991028153bd194ca97f4b55e610c73ce66a" +checksum = "dc5f2297ee5b893405bed1a6929faec4713a061df158ecf5198089f23910d470" dependencies = [ "anyhow", "camino", @@ -7818,9 +8037,9 @@ dependencies = [ [[package]] name = "uniffi_bindgen" -version = "0.31.0" +version = "0.31.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4ed0150801958d4825da56a41c71f000a457ac3a4613fa9647df78ac4b6b6881" +checksum = "8bc0c60a9607e7ab77a2ad47ec5530178015014839db25af7512447d2238016c" dependencies = [ "anyhow", "askama", @@ -7835,7 +8054,7 @@ dependencies = [ "serde", "tempfile", "textwrap", - "toml 0.9.7", + "toml 0.9.12+spec-1.1.0", "uniffi_internal_macros", "uniffi_meta", "uniffi_pipeline", @@ -7844,9 +8063,9 @@ dependencies = [ [[package]] name = "uniffi_build" -version = "0.31.0" +version = "0.31.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b78fd9271a4c2e85bd2c266c5a9ede1fac676eb39fd77f636c27eaf67426fd5f" +checksum = "4c39413c43b955e4aa8a4e2b34bbd1b6b5ff6bd85532b52f9eb92fbe88c14458" dependencies = [ "anyhow", "camino", @@ -7855,9 +8074,9 @@ dependencies = [ [[package]] name = "uniffi_core" -version = "0.31.0" +version = "0.31.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b0ef62e69762fbb9386dcb6c87cd3dd05d525fa8a3a579a290892e60ddbda47e" +checksum = "77baf5d539fe2e1ad6805e942dbc5dbdeb2b83eb5f2b3a6535d422ca4b02a12f" dependencies = [ "anyhow", "async-compat", @@ -7868,9 +8087,9 @@ dependencies = [ [[package]] name = "uniffi_internal_macros" -version = "0.31.0" +version = "0.31.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "98f51ebca0d9a4b2aa6c644d5ede45c56f73906b96403c08a1985e75ccb64a01" +checksum = "b4b42137524f4be6400fcaca9d02c1d4ecb6ad917e4013c0b93235526d8396e5" dependencies = [ "anyhow", "indexmap", @@ -7881,9 +8100,9 @@ dependencies = [ [[package]] name = "uniffi_macros" -version = "0.31.0" +version = "0.31.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "db9d12529f1223d014fd501e5f29ca0884d15d6ed5ddddd9f506e55350327dc3" +checksum = "d9273ec45330d8fe9a3701b7b983cea7a4e218503359831967cb95d26b873561" dependencies = [ "camino", "fs-err", @@ -7892,15 +8111,15 @@ dependencies = [ "quote", "serde", "syn 2.0.117", - "toml 0.9.7", + "toml 0.9.12+spec-1.1.0", "uniffi_meta", ] [[package]] name = "uniffi_meta" -version = "0.31.0" +version = "0.31.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9df6d413db2827c68588f8149d30d49b71d540d46539e435b23a7f7dbd4d4f86" +checksum = "431d2f443e7828a6c29d188de98b6771a6491ee98bba2d4372643bf93f988a18" dependencies = [ "anyhow", "siphasher", @@ -7910,9 +8129,9 @@ dependencies = [ [[package]] name = "uniffi_pipeline" -version = "0.31.0" +version = "0.31.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a806dddc8208f22efd7e95a5cdf88ed43d0f3271e8f63b47e757a8bbdb43b63a" +checksum = "761ef74f6175e15603d0424cc5f98854c5baccfe7bf4ccb08e5816f9ab8af689" dependencies = [ "anyhow", "heck 0.5.0", @@ -7923,9 +8142,9 @@ dependencies = [ [[package]] name = "uniffi_udl" -version = "0.31.0" +version = "0.31.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0d1a7339539bf6f6fa3e9b534dece13f778bda2d54b1a6d4e40b4d6090ac26e7" +checksum = "68773ec0e1c067b6505a73bbf6a5782f31a7f9209333a0df97b87565c46bf370" dependencies = [ "anyhow", "textwrap", @@ -7951,14 +8170,15 @@ checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" [[package]] name = "url" -version = "2.5.7" +version = "2.5.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "08bc136a29a3d1758e07a9cca267be308aeebf5cfd5a10f3f67ab2097683ef5b" +checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed" dependencies = [ "form_urlencoded", "idna", "percent-encoding", "serde", + "serde_derive", ] [[package]] @@ -7973,12 +8193,6 @@ version = "0.7.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9" -[[package]] -name = "utf16_iter" -version = "1.0.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c8232dd3cdaed5356e0f716d285e4b40b932ac434100fe9b7e0e8e935b9e6246" - [[package]] name = "utf8-ranges" version = "1.0.5" @@ -7993,13 +8207,13 @@ checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" [[package]] name = "uuid" -version = "1.18.1" +version = "1.23.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2f87b8aa10b915a06587d0dec516c282ff295b475d94abf425d62b57710070a2" +checksum = "ddd74a9687298c6858e9b88ec8935ec45d22e8fd5e6394fa1bd4e99a87789c76" dependencies = [ - "getrandom 0.3.4", + "getrandom 0.4.2", "js-sys", - "serde", + "serde_core", "wasm-bindgen", ] @@ -8025,9 +8239,9 @@ dependencies = [ [[package]] name = "valuable" -version = "0.1.0" +version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d" +checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" [[package]] name = "value-bag" @@ -8043,15 +8257,15 @@ checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426" [[package]] name = "vergen" -version = "9.0.6" +version = "9.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6b2bf58be11fc9414104c6d3a2e464163db5ef74b12296bda593cac37b6e4777" +checksum = "b849a1f6d8639e8de261e81ee0fc881e3e3620db1af9f2e0da015d4382ceaf75" dependencies = [ "anyhow", "derive_builder", "rustversion", "time", - "vergen-lib", + "vergen-lib 9.1.0", ] [[package]] @@ -8065,7 +8279,7 @@ dependencies = [ "rustversion", "time", "vergen", - "vergen-lib", + "vergen-lib 0.1.6", ] [[package]] @@ -8079,6 +8293,17 @@ dependencies = [ "rustversion", ] +[[package]] +name = "vergen-lib" +version = "9.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b34a29ba7e9c59e62f229ae1932fb1b8fb8a6fdcc99215a641913f5f5a59a569" +dependencies = [ + "anyhow", + "derive_builder", + "rustversion", +] + [[package]] name = "version-compare" version = "0.2.1" @@ -8087,9 +8312,9 @@ checksum = "03c2856837ef78f57382f06b2b8563a2f512f7185d732608fd9176cb3b8edf0e" [[package]] name = "version_check" -version = "0.9.4" +version = "0.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" [[package]] name = "vodozemac" @@ -8105,12 +8330,12 @@ dependencies = [ "chacha20poly1305", "curve25519-dalek", "ed25519-dalek", - "getrandom 0.2.15", + "getrandom 0.2.17", "hkdf", "hmac", "matrix-pickle", "prost 0.14.3", - "rand 0.8.5", + "rand 0.8.6", "serde", "serde_bytes", "serde_json", @@ -8142,17 +8367,17 @@ dependencies = [ [[package]] name = "wasi" -version = "0.11.0+wasi-snapshot-preview1" +version = "0.11.1+wasi-snapshot-preview1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" +checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" [[package]] name = "wasip2" -version = "1.0.2+wasi-0.2.9" +version = "1.0.3+wasi-0.2.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5" +checksum = "20064672db26d7cdc89c7798c48a0fdfac8213434a1186e5ef29fd560ae223d6" dependencies = [ - "wit-bindgen", + "wit-bindgen 0.57.1", ] [[package]] @@ -8161,14 +8386,14 @@ version = "0.4.0+wasi-0.3.0-rc-2026-01-06" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5" dependencies = [ - "wit-bindgen", + "wit-bindgen 0.51.0", ] [[package]] name = "wasm-bindgen" -version = "0.2.114" +version = "0.2.121" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6532f9a5c1ece3798cb1c2cfdba640b9b3ba884f5db45973a6f442510a87d38e" +checksum = "49ace1d07c165b0864824eee619580c4689389afa9dc9ed3a4c75040d82e6790" dependencies = [ "cfg-if", "once_cell", @@ -8179,23 +8404,19 @@ dependencies = [ [[package]] name = "wasm-bindgen-futures" -version = "0.4.64" +version = "0.4.71" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e9c5522b3a28661442748e09d40924dfb9ca614b21c00d3fd135720e48b67db8" +checksum = "96492d0d3ffba25305a7dc88720d250b1401d7edca02cc3bcd50633b424673b8" dependencies = [ - "cfg-if", - "futures-util", "js-sys", - "once_cell", "wasm-bindgen", - "web-sys", ] [[package]] name = "wasm-bindgen-macro" -version = "0.2.114" +version = "0.2.121" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "18a2d50fcf105fb33bb15f00e7a77b772945a2ee45dcf454961fd843e74c18e6" +checksum = "8e68e6f4afd367a562002c05637acb8578ff2dea1943df76afb9e83d177c8578" dependencies = [ "quote", "wasm-bindgen-macro-support", @@ -8203,9 +8424,9 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro-support" -version = "0.2.114" +version = "0.2.121" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "03ce4caeaac547cdf713d280eda22a730824dd11e6b8c3ca9e42247b25c631e3" +checksum = "d95a9ec35c64b2a7cb35d3fead40c4238d0940c86d107136999567a4703259f2" dependencies = [ "bumpalo", "proc-macro2", @@ -8216,18 +8437,18 @@ dependencies = [ [[package]] name = "wasm-bindgen-shared" -version = "0.2.114" +version = "0.2.121" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "75a326b8c223ee17883a4251907455a2431acc2791c98c26279376490c378c16" +checksum = "c4e0100b01e9f0d03189a92b96772a1fb998639d981193d7dbab487302513441" dependencies = [ "unicode-ident", ] [[package]] name = "wasm-bindgen-test" -version = "0.3.64" +version = "0.3.71" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6311c867385cc7d5602463b31825d454d0837a3aba7cdb5e56d5201792a3f7fe" +checksum = "af5ec93229ad9ccd0a545a516dec76dc276613f278f6a91aa6b463d5b33d42d0" dependencies = [ "async-trait", "cast", @@ -8247,9 +8468,9 @@ dependencies = [ [[package]] name = "wasm-bindgen-test-macro" -version = "0.3.64" +version = "0.3.71" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "67008cdde4769831958536b0f11b3bdd0380bde882be17fff9c2f34bb4549abd" +checksum = "3c81b9fef827e575e0e54431736d1baa0d700315d8c62cfef1f61fa3aad0cbeb" dependencies = [ "proc-macro2", "quote", @@ -8258,9 +8479,9 @@ dependencies = [ [[package]] name = "wasm-bindgen-test-shared" -version = "0.2.114" +version = "0.2.121" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cfe29135b180b72b04c74aa97b2b4a2ef275161eff9a6c7955ea9eaedc7e1d4e" +checksum = "4f4d8ae7ad5440360e9799dfd42857d126454a88441ddf72d288ef83fa47f527" [[package]] name = "wasm-encoder" @@ -8321,17 +8542,17 @@ version = "0.244.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe" dependencies = [ - "bitflags 2.10.0", - "hashbrown 0.15.2", + "bitflags 2.11.1", + "hashbrown 0.15.5", "indexmap", "semver", ] [[package]] name = "web-sys" -version = "0.3.91" +version = "0.3.98" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "854ba17bb104abfb26ba36da9729addc7ce7f06f5c0f90f3c391f8461cca21f9" +checksum = "4b572dff8bcf38bad0fa19729c89bb5748b2b9b1d8be70cf90df697e3a8f32aa" dependencies = [ "js-sys", "wasm-bindgen", @@ -8350,9 +8571,9 @@ dependencies = [ [[package]] name = "web_atoms" -version = "0.2.3" +version = "0.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "57a9779e9f04d2ac1ce317aee707aa2f6b773afba7b931222bff6983843b1576" +checksum = "d7cff6eef815df1834fd250e3a2ff436044d82a9f1bc1980ca1dbdf07effc538" dependencies = [ "phf", "phf_codegen", @@ -8362,18 +8583,18 @@ dependencies = [ [[package]] name = "webpki-root-certs" -version = "1.0.2" +version = "1.0.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4e4ffd8df1c57e87c325000a3d6ef93db75279dc3a231125aac571650f22b12a" +checksum = "f31141ce3fc3e300ae89b78c0dd67f9708061d1d2eda54b8209346fd6be9a92c" dependencies = [ "rustls-pki-types", ] [[package]] name = "webpki-roots" -version = "1.0.6" +version = "1.0.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "22cfaf3c063993ff62e73cb4311efde4db1efb31ab78a3e5c457939ad5cc0bed" +checksum = "52f5ee44c96cf55f1b349600768e3ece3a8f26010c05265ab73f945bb1a2eb9d" dependencies = [ "rustls-pki-types", ] @@ -8424,7 +8645,7 @@ dependencies = [ "either", "home", "once_cell", - "rustix 0.38.41", + "rustix 0.38.44", ] [[package]] @@ -8451,11 +8672,11 @@ checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" [[package]] name = "winapi-util" -version = "0.1.8" +version = "0.1.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4d4cc384e1e73b93bafa6fb4f1df8c41695c8a91cf9c4c64358067d15a7b6c6b" +checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" dependencies = [ - "windows-sys 0.52.0", + "windows-sys 0.61.2", ] [[package]] @@ -8464,66 +8685,24 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" -[[package]] -name = "windows" -version = "0.61.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c5ee8f3d025738cb02bad7868bbb5f8a6327501e870bf51f1b455b0a2454a419" -dependencies = [ - "windows-collections", - "windows-core 0.61.2", - "windows-future", - "windows-link 0.1.1", - "windows-numerics", -] - -[[package]] -name = "windows-collections" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8" -dependencies = [ - "windows-core 0.61.2", -] - -[[package]] -name = "windows-core" -version = "0.52.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9" -dependencies = [ - "windows-targets 0.52.6", -] - [[package]] name = "windows-core" -version = "0.61.2" +version = "0.62.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3" +checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb" dependencies = [ "windows-implement", "windows-interface", - "windows-link 0.1.1", + "windows-link", "windows-result", "windows-strings", ] -[[package]] -name = "windows-future" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e" -dependencies = [ - "windows-core 0.61.2", - "windows-link 0.1.1", - "windows-threading", -] - [[package]] name = "windows-implement" -version = "0.60.0" +version = "0.60.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836" +checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" dependencies = [ "proc-macro2", "quote", @@ -8532,64 +8711,48 @@ dependencies = [ [[package]] name = "windows-interface" -version = "0.59.1" +version = "0.59.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8" +checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" dependencies = [ "proc-macro2", "quote", "syn 2.0.117", ] -[[package]] -name = "windows-link" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "76840935b766e1b0a05c0066835fb9ec80071d4c09a16f6bd5f7e655e3c14c38" - [[package]] name = "windows-link" version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" -[[package]] -name = "windows-numerics" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1" -dependencies = [ - "windows-core 0.61.2", - "windows-link 0.1.1", -] - [[package]] name = "windows-registry" -version = "0.5.2" +version = "0.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b3bab093bdd303a1240bb99b8aba8ea8a69ee19d34c9e2ef9594e708a4878820" +checksum = "02752bf7fbdcce7f2a27a742f798510f3e5ad88dbe84871e5168e2120c3d5720" dependencies = [ - "windows-link 0.1.1", + "windows-link", "windows-result", "windows-strings", ] [[package]] name = "windows-result" -version = "0.3.4" +version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6" +checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5" dependencies = [ - "windows-link 0.1.1", + "windows-link", ] [[package]] name = "windows-strings" -version = "0.4.2" +version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57" +checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091" dependencies = [ - "windows-link 0.1.1", + "windows-link", ] [[package]] @@ -8601,15 +8764,6 @@ dependencies = [ "windows-targets 0.42.2", ] -[[package]] -name = "windows-sys" -version = "0.48.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9" -dependencies = [ - "windows-targets 0.48.5", -] - [[package]] name = "windows-sys" version = "0.52.0" @@ -8643,7 +8797,7 @@ version = "0.61.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" dependencies = [ - "windows-link 0.2.1", + "windows-link", ] [[package]] @@ -8661,21 +8815,6 @@ dependencies = [ "windows_x86_64_msvc 0.42.2", ] -[[package]] -name = "windows-targets" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c" -dependencies = [ - "windows_aarch64_gnullvm 0.48.5", - "windows_aarch64_msvc 0.48.5", - "windows_i686_gnu 0.48.5", - "windows_i686_msvc 0.48.5", - "windows_x86_64_gnu 0.48.5", - "windows_x86_64_gnullvm 0.48.5", - "windows_x86_64_msvc 0.48.5", -] - [[package]] name = "windows-targets" version = "0.52.6" @@ -8698,7 +8837,7 @@ version = "0.53.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3" dependencies = [ - "windows-link 0.2.1", + "windows-link", "windows_aarch64_gnullvm 0.53.1", "windows_aarch64_msvc 0.53.1", "windows_i686_gnu 0.53.1", @@ -8709,27 +8848,12 @@ dependencies = [ "windows_x86_64_msvc 0.53.1", ] -[[package]] -name = "windows-threading" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6" -dependencies = [ - "windows-link 0.1.1", -] - [[package]] name = "windows_aarch64_gnullvm" version = "0.42.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8" -[[package]] -name = "windows_aarch64_gnullvm" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8" - [[package]] name = "windows_aarch64_gnullvm" version = "0.52.6" @@ -8748,12 +8872,6 @@ version = "0.42.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43" -[[package]] -name = "windows_aarch64_msvc" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc" - [[package]] name = "windows_aarch64_msvc" version = "0.52.6" @@ -8772,12 +8890,6 @@ version = "0.42.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f" -[[package]] -name = "windows_i686_gnu" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e" - [[package]] name = "windows_i686_gnu" version = "0.52.6" @@ -8808,12 +8920,6 @@ version = "0.42.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060" -[[package]] -name = "windows_i686_msvc" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406" - [[package]] name = "windows_i686_msvc" version = "0.52.6" @@ -8832,12 +8938,6 @@ version = "0.42.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36" -[[package]] -name = "windows_x86_64_gnu" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e" - [[package]] name = "windows_x86_64_gnu" version = "0.52.6" @@ -8856,12 +8956,6 @@ version = "0.42.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3" -[[package]] -name = "windows_x86_64_gnullvm" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc" - [[package]] name = "windows_x86_64_gnullvm" version = "0.52.6" @@ -8880,12 +8974,6 @@ version = "0.42.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0" -[[package]] -name = "windows_x86_64_msvc" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538" - [[package]] name = "windows_x86_64_msvc" version = "0.52.6" @@ -8900,18 +8988,18 @@ checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650" [[package]] name = "winnow" -version = "0.7.13" +version = "0.7.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf" +checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945" dependencies = [ "memchr", ] [[package]] name = "winnow" -version = "1.0.1" +version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "09dac053f1cd375980747450bfc7250c264eaae0583872e845c0c7cd578872b5" +checksum = "2ee1708bef14716a11bae175f579062d4554d95be2c6829f518df847b7b3fdd0" dependencies = [ "memchr", ] @@ -8926,7 +9014,7 @@ dependencies = [ "base64 0.22.1", "deadpool 0.12.3", "futures", - "http 1.3.1", + "http 1.4.0", "http-body-util", "hyper", "hyper-util", @@ -8948,6 +9036,12 @@ dependencies = [ "wit-bindgen-rust-macro", ] +[[package]] +name = "wit-bindgen" +version = "0.57.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e" + [[package]] name = "wit-bindgen-core" version = "0.51.0" @@ -8997,7 +9091,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2" dependencies = [ "anyhow", - "bitflags 2.10.0", + "bitflags 2.11.1", "indexmap", "log", "serde", @@ -9027,17 +9121,11 @@ dependencies = [ "wasmparser", ] -[[package]] -name = "write16" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d1890f4022759daae28ed4fe62859b1236caebfc61ede2f63ed4e695f3f6d936" - [[package]] name = "writeable" -version = "0.5.5" +version = "0.6.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e9df38ee2d2c3c5948ea468a8406ff0db0b29ae1ffde1bcf20ef305bcc95c51" +checksum = "1ffae5123b2d3fc086436f8834ae3ab053a283cfac8fe0a0b8eaae044768a4c4" [[package]] name = "x25519-dalek" @@ -9053,18 +9141,18 @@ dependencies = [ [[package]] name = "xshell" -version = "0.2.2" +version = "0.2.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6d47097dc5c85234b1e41851b3422dd6d19b3befdd35b4ae5ce386724aeca981" +checksum = "9e7290c623014758632efe00737145b6867b66292c42167f2ec381eb566a373d" dependencies = [ "xshell-macros", ] [[package]] name = "xshell-macros" -version = "0.2.2" +version = "0.2.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "88301b56c26dd9bf5c43d858538f82d6f3f7764767defbc5d34e59459901c41a" +checksum = "32ac00cd3f8ec9c1d33fb3e7958a82df6989c42d747bd326c822b1d625283547" [[package]] name = "xtask" @@ -9086,17 +9174,16 @@ dependencies = [ [[package]] name = "xxhash-rust" -version = "0.8.11" +version = "0.8.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "63658493314859b4dfdf3fb8c1defd61587839def09582db50b8a4e93afca6bb" +checksum = "fdd20c5420375476fbd4394763288da7eb0cc0b8c11deed431a91562af7335d3" [[package]] name = "yoke" -version = "0.7.5" +version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "120e6aef9aa629e3d4f52dc8cc43a015c7724194c97dfaf45180d2daf2b77f40" +checksum = "abe8c5fda708d9ca3df187cae8bfb9ceda00dd96231bed36e445a1a48e66f9ca" dependencies = [ - "serde", "stable_deref_trait", "yoke-derive", "zerofrom", @@ -9104,9 +9191,9 @@ dependencies = [ [[package]] name = "yoke-derive" -version = "0.7.5" +version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2380878cad4ac9aac1e2435f3eb4020e8374b5f13c296cb75b4620ff8e229154" +checksum = "de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e" dependencies = [ "proc-macro2", "quote", @@ -9116,18 +9203,18 @@ dependencies = [ [[package]] name = "zerocopy" -version = "0.7.35" +version = "0.8.48" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0" +checksum = "eed437bf9d6692032087e337407a86f04cd8d6a16a37199ed57949d415bd68e9" dependencies = [ "zerocopy-derive", ] [[package]] name = "zerocopy-derive" -version = "0.7.35" +version = "0.8.48" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e" +checksum = "70e3cd084b1788766f53af483dd21f93881ff30d7320490ec3ef7526d203bad4" dependencies = [ "proc-macro2", "quote", @@ -9136,18 +9223,18 @@ dependencies = [ [[package]] name = "zerofrom" -version = "0.1.5" +version = "0.1.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cff3ee08c995dee1859d998dea82f7374f2826091dd9cd47def953cae446cd2e" +checksum = "69faa1f2a1ea75661980b013019ed6687ed0e83d069bc1114e2cc74c6c04c4df" dependencies = [ "zerofrom-derive", ] [[package]] name = "zerofrom-derive" -version = "0.1.5" +version = "0.1.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "595eed982f7d355beb85837f651fa22e90b3c044842dc7f2c2842c086f295808" +checksum = "11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1" dependencies = [ "proc-macro2", "quote", @@ -9166,9 +9253,9 @@ dependencies = [ [[package]] name = "zeroize_derive" -version = "1.4.2" +version = "1.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69" +checksum = "85a5b4158499876c763cb03bc4e49185d3cccbabb15b33c627f7884f43db852e" dependencies = [ "proc-macro2", "quote", @@ -9194,19 +9281,30 @@ dependencies = [ "num-traits", "once_cell", "parking_lot", - "rand 0.8.5", + "rand 0.8.6", "regex", - "thiserror 1.0.63", + "thiserror 1.0.69", "tokio", "tokio-util", "uuid", ] +[[package]] +name = "zerotrie" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f9152d31db0792fa83f70fb2f83148effb5c1f5b8c7686c3459e361d9bc20bf" +dependencies = [ + "displaydoc", + "yoke", + "zerofrom", +] + [[package]] name = "zerovec" -version = "0.10.4" +version = "0.11.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aa2b893d79df23bfb12d5461018d408ea19dfafe76c2c7ef6d4eba614f8ff079" +checksum = "90f911cbc359ab6af17377d242225f4d75119aec87ea711a880987b18cd7b239" dependencies = [ "yoke", "zerofrom", @@ -9215,9 +9313,9 @@ dependencies = [ [[package]] name = "zerovec-derive" -version = "0.10.3" +version = "0.11.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6eafa6dfb17584ea3e2bd6e76e0cc15ad7af12b09abdd1ca55961bed9b1063c6" +checksum = "625dc425cab0dca6dc3c3319506e6593dcb08a9f387ea3b284dbd52a92c40555" dependencies = [ "proc-macro2", "quote", @@ -9244,6 +9342,12 @@ dependencies = [ "zstd 0.11.2+zstd.1.5.2", ] +[[package]] +name = "zmij" +version = "1.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa" + [[package]] name = "zstd" version = "0.11.2+zstd.1.5.2" @@ -9283,9 +9387,9 @@ dependencies = [ [[package]] name = "zstd-sys" -version = "2.0.15+zstd.1.5.7" +version = "2.0.16+zstd.1.5.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eb81183ddd97d0c74cedf1d50d85c8d08c1b8b68ee863bdee9e706eedba1a237" +checksum = "91e19ebc2adc8f83e43039e79776e3fda8ca919132d68a1fed6a5faca2683748" dependencies = [ "cc", "pkg-config", diff --git a/crates/matrix-sdk-rtc-livekit/Cargo.toml b/crates/matrix-sdk-rtc-livekit/Cargo.toml index 47ceb2a2013..24e388ee2e4 100644 --- a/crates/matrix-sdk-rtc-livekit/Cargo.toml +++ b/crates/matrix-sdk-rtc-livekit/Cargo.toml @@ -21,6 +21,7 @@ experimental-widgets = ["matrix-sdk/experimental-widgets"] [dependencies] async-trait.workspace = true base64.workspace = true +#livekit = { version = "0.7.38"} livekit = { git = "https://github.com/onestacked/livekit-rust-sdks", branch = "EC-compat-changes" } matrix-sdk = { workspace = true, features = ["e2e-encryption", "experimental-send-custom-to-device"] } matrix-sdk-base.workspace = true diff --git a/crates/matrix-sdk-rtc-livekit/README.md b/crates/matrix-sdk-rtc-livekit/README.md index 41fc053eb40..358323a861e 100644 --- a/crates/matrix-sdk-rtc-livekit/README.md +++ b/crates/matrix-sdk-rtc-livekit/README.md @@ -1,42 +1,3 @@ # matrix-sdk-rtc-livekit LiveKit SDK integration for MatrixRTC room calls, including the connection traits and service URL helpers. - -## Toolchain setup (Linux) - -The LiveKit Rust SDK builds native WebRTC components. On Linux, the build is -most reliable with clang and libc++. - -Install libc++ and libc++abi (Ubuntu/Debian): - -```bash -sudo apt-get install -y libc++-dev libc++abi-dev -``` - -Build with clang + libc++: - -```bash -CC=clang CXX=clang++ CXXFLAGS="-stdlib=libc++" \ - cargo build -p matrix-sdk-rtc-livekit -``` - -If clang still picks GCC's headers, force the libc++ include path: - -```bash -CC=clang CXX=clang++ CXXFLAGS="-stdlib=libc++ -isystem /usr/include/c++/v1" \ - cargo build -p matrix-sdk-rtc-livekit -``` - -### Linker errors about `std::__1` symbols - -If you see linker errors that mention `std::__1` (libc++), it means some native -objects were built against libc++ but the final link step is using libstdc++. - -Try one of the following: - -- Ensure libc++ and libc++abi are installed (see above). -- Explicitly link libc++/libc++abi when building: - -```bash -RUSTFLAGS="-l c++ -l c++abi" cargo build -p matrix-sdk-rtc-livekit -``` diff --git a/examples/rtc_livekit_join/README.md b/examples/rtc_livekit_join/README.md index 7e820f8b8e0..548de0b31f0 100644 --- a/examples/rtc_livekit_join/README.md +++ b/examples/rtc_livekit_join/README.md @@ -1,4 +1,4 @@ -# LiveKit call join (skeleton) +# LiveKit call join This example shows how to use `matrix-sdk-rtc-livekit` to join/leave a LiveKit room with Element-Call based SFrame Encryption based on MatrixRTC call memberships. From 80c7e6b339b6c43b4857d382ec0d1d4a72675afc Mon Sep 17 00:00:00 2001 From: herrfeder <14598229+herrfeder@users.noreply.github.com> Date: Tue, 12 May 2026 10:05:39 +0200 Subject: [PATCH 4/5] test addition of glib2.0-dev in coverage job to check buildw --- .github/workflows/coverage.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml index db8e928b741..f5079c1d61c 100644 --- a/.github/workflows/coverage.yml +++ b/.github/workflows/coverage.yml @@ -110,7 +110,7 @@ jobs: - name: Install libsqlite run: | sudo apt-get update - sudo apt-get install libsqlite3-dev + sudo apt-get install libsqlite3-dev libglib2.0-dev sudo apt-get clean sudo rm -rf /var/lib/apt/lists/* From 28b20cf3e2ded7e324fe09b3b84fb14b3760d589 Mon Sep 17 00:00:00 2001 From: herrfeder <14598229+herrfeder@users.noreply.github.com> Date: Tue, 12 May 2026 10:55:00 +0200 Subject: [PATCH 5/5] test addition of libva-dev in coverage job to check build --- .github/workflows/coverage.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml index f5079c1d61c..d75021b8604 100644 --- a/.github/workflows/coverage.yml +++ b/.github/workflows/coverage.yml @@ -110,7 +110,7 @@ jobs: - name: Install libsqlite run: | sudo apt-get update - sudo apt-get install libsqlite3-dev libglib2.0-dev + sudo apt-get install libsqlite3-dev libglib2.0-dev libva-dev sudo apt-get clean sudo rm -rf /var/lib/apt/lists/*