commit 6638d84dc7017108e218196e8e3f4234b901885e
parent 7e06829b72657707cb4de95e837af9b188745f65
Author: triesap <tyson@radroots.org>
Date: Tue, 20 Oct 2026 05:10:41 +0000
transport: Add bounded origin-thread browser socket I/O
- Keep DOM state local behind safe owned messages and frozen socket limits
- Reuse shared Nostr verification, sessions and original-byte publication
- Verify real page and worker I/O, acknowledgement handling and cancellation
- Preserve private provenance and unchanged source, API and coverage gates
Diffstat:
21 files changed, 4340 insertions(+), 10 deletions(-)
diff --git a/Cargo.lock b/Cargo.lock
@@ -3788,6 +3788,22 @@ dependencies = [
]
[[package]]
+name = "radroots_transport_nostr_browser"
+version = "0.1.0-alpha"
+dependencies = [
+ "async-utility",
+ "futures",
+ "js-sys",
+ "radroots_transport",
+ "radroots_transport_nostr",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+ "web-time",
+]
+
+[[package]]
name = "radroots_transport_nostr_native"
version = "0.1.0-alpha"
dependencies = [
diff --git a/Cargo.toml b/Cargo.toml
@@ -20,6 +20,7 @@ members = [
"crates/nostrdb",
"crates/transport_nostr",
"crates/transport_nostr_native",
+ "crates/transport_nostr_browser",
"crates/transport_reticulum",
"crates/simplex_app_store",
"crates/simplex_agent_proto",
@@ -138,6 +139,7 @@ radroots_service_host = { path = "crates/service_host", version = "=0.1.0-alpha"
radroots_service_sqlite = { path = "crates/service_sqlite", version = "=0.1.0-alpha", default-features = false }
radroots_transport_nostr = { package = "radroots_transport_nostr", path = "crates/transport_nostr", version = "=0.1.0-alpha", default-features = false }
radroots_transport_nostr_native = { package = "radroots_transport_nostr_native", path = "crates/transport_nostr_native", version = "=0.1.0-alpha", default-features = false }
+radroots_transport_nostr_browser = { path = "crates/transport_nostr_browser", version = "=0.1.0-alpha", default-features = false }
radroots_transport_reticulum = { path = "crates/transport_reticulum", version = "=0.1.0-alpha", default-features = false }
radroots_simplex_agent_proto = { path = "crates/simplex_agent_proto", version = "=0.1.0-alpha", default-features = false }
radroots_simplex_chat_proto = { path = "crates/simplex_chat_proto", version = "=0.1.0-alpha", default-features = false }
diff --git a/contracts/coverage.toml b/contracts/coverage.toml
@@ -75,6 +75,7 @@ crates = [
"radroots_sync",
"radroots_transport_nostr",
"radroots_transport_nostr_native",
+ "radroots_transport_nostr_browser",
"radroots_transport_reticulum",
"radroots_replica_store",
"radroots_replica_store_wasm",
diff --git a/contracts/crates/catalog.v2.toml b/contracts/crates/catalog.v2.toml
@@ -7,7 +7,7 @@ rust_version = "1.99.0"
edition = "2024"
resolver = "3"
public_package_count = 22
-package_count = 55
+package_count = 56
digest_algorithm = "sha256-raw-bytes-v1"
source_tree_digest_algorithm = "sha256-git-ls-tree-r-v1"
native_introduction_tree_digest_algorithm = "sha256-git-tree-records-z-v1"
@@ -409,6 +409,24 @@ compatibility = ["rust_api", "network", "features", "package"]
replaces = []
[[package]]
+name = "radroots_transport_nostr_browser"
+path = "crates/transport_nostr_browser"
+state = "active"
+tier = "adapter"
+visibility = "private_adapter"
+publish = false
+version = "0.1.0-alpha"
+license = "MIT OR Apache-2.0"
+platforms = ["wasm32"]
+groups = ["coverage_required", "wasm"]
+owners = ["transport"]
+permitted_dependency_tiers = ["foundation", "domain", "spi", "adapter"]
+provenance_kind = "native"
+introduction_tree_sha256 = "bc8425c519ca6d3921d8e05c454ee01e4644bd86ae7ff2bf2818ab6ea1dd2685"
+compatibility = ["package_private", "rust_api", "network"]
+replaces = []
+
+[[package]]
name = "radroots_transport_nostr_native"
path = "crates/transport_nostr_native"
state = "active"
diff --git a/contracts/crates/generated/package_groups.v1.toml b/contracts/crates/generated/package_groups.v1.toml
@@ -1,5 +1,5 @@
schema = "radroots.workspace.package-groups.v1"
-catalog_sha256 = "9dc291f170c1888cd2f9e9acb10c1251e32dd7b94c9b3c347feb7a6eaa44b475"
+catalog_sha256 = "00210ad66c7305d5e57f24e821a0c215e8bd9db25a1382490d6710aca88d3650"
[[group]]
id = "boundaries"
@@ -9,8 +9,8 @@ reserved_packages = []
[[group]]
id = "coverage_required"
-packages = ["radroots", "radroots_blossom", "radroots_core", "radroots_core_bindings", "radroots_domain", "radroots_event", "radroots_event_bindings", "radroots_event_codec", "radroots_event_codec_wasm", "radroots_execution", "radroots_geonames", "radroots_identity", "radroots_identity_bindings", "radroots_mesh", "radroots_mesh_agent_client", "radroots_mesh_agent_proto", "radroots_nostr", "radroots_nostr_connect", "radroots_nostrdb", "radroots_protocol", "radroots_replica_schema", "radroots_replica_schema_bindings", "radroots_replica_store", "radroots_replica_store_wasm", "radroots_replica_sync", "radroots_replica_sync_wasm", "radroots_runtime_distribution", "radroots_runtime_manager", "radroots_runtime_paths", "radroots_sdk", "radroots_sdk_ffi", "radroots_sdk_sql_wasm_runtime", "radroots_secrets", "radroots_service_host", "radroots_service_sqlite", "radroots_signing", "radroots_sql_core", "radroots_storage", "radroots_storage_indexeddb", "radroots_storage_sqlite", "radroots_sync", "radroots_test_fixtures", "radroots_trade", "radroots_trade_bindings", "radroots_transport", "radroots_transport_nostr", "radroots_transport_nostr_native", "radroots_transport_reticulum", "xtask"]
-active_packages = ["radroots", "radroots_blossom", "radroots_core", "radroots_core_bindings", "radroots_domain", "radroots_event", "radroots_event_bindings", "radroots_event_codec", "radroots_event_codec_wasm", "radroots_execution", "radroots_geonames", "radroots_identity", "radroots_identity_bindings", "radroots_mesh", "radroots_mesh_agent_client", "radroots_mesh_agent_proto", "radroots_nostr", "radroots_nostr_connect", "radroots_nostrdb", "radroots_protocol", "radroots_replica_schema", "radroots_replica_schema_bindings", "radroots_replica_store", "radroots_replica_store_wasm", "radroots_replica_sync", "radroots_replica_sync_wasm", "radroots_runtime_distribution", "radroots_runtime_manager", "radroots_runtime_paths", "radroots_sdk", "radroots_sdk_ffi", "radroots_sdk_sql_wasm_runtime", "radroots_secrets", "radroots_service_host", "radroots_service_sqlite", "radroots_signing", "radroots_sql_core", "radroots_storage", "radroots_storage_indexeddb", "radroots_storage_sqlite", "radroots_sync", "radroots_test_fixtures", "radroots_trade", "radroots_trade_bindings", "radroots_transport", "radroots_transport_nostr", "radroots_transport_nostr_native", "radroots_transport_reticulum", "xtask"]
+packages = ["radroots", "radroots_blossom", "radroots_core", "radroots_core_bindings", "radroots_domain", "radroots_event", "radroots_event_bindings", "radroots_event_codec", "radroots_event_codec_wasm", "radroots_execution", "radroots_geonames", "radroots_identity", "radroots_identity_bindings", "radroots_mesh", "radroots_mesh_agent_client", "radroots_mesh_agent_proto", "radroots_nostr", "radroots_nostr_connect", "radroots_nostrdb", "radroots_protocol", "radroots_replica_schema", "radroots_replica_schema_bindings", "radroots_replica_store", "radroots_replica_store_wasm", "radroots_replica_sync", "radroots_replica_sync_wasm", "radroots_runtime_distribution", "radroots_runtime_manager", "radroots_runtime_paths", "radroots_sdk", "radroots_sdk_ffi", "radroots_sdk_sql_wasm_runtime", "radroots_secrets", "radroots_service_host", "radroots_service_sqlite", "radroots_signing", "radroots_sql_core", "radroots_storage", "radroots_storage_indexeddb", "radroots_storage_sqlite", "radroots_sync", "radroots_test_fixtures", "radroots_trade", "radroots_trade_bindings", "radroots_transport", "radroots_transport_nostr", "radroots_transport_nostr_browser", "radroots_transport_nostr_native", "radroots_transport_reticulum", "xtask"]
+active_packages = ["radroots", "radroots_blossom", "radroots_core", "radroots_core_bindings", "radroots_domain", "radroots_event", "radroots_event_bindings", "radroots_event_codec", "radroots_event_codec_wasm", "radroots_execution", "radroots_geonames", "radroots_identity", "radroots_identity_bindings", "radroots_mesh", "radroots_mesh_agent_client", "radroots_mesh_agent_proto", "radroots_nostr", "radroots_nostr_connect", "radroots_nostrdb", "radroots_protocol", "radroots_replica_schema", "radroots_replica_schema_bindings", "radroots_replica_store", "radroots_replica_store_wasm", "radroots_replica_sync", "radroots_replica_sync_wasm", "radroots_runtime_distribution", "radroots_runtime_manager", "radroots_runtime_paths", "radroots_sdk", "radroots_sdk_ffi", "radroots_sdk_sql_wasm_runtime", "radroots_secrets", "radroots_service_host", "radroots_service_sqlite", "radroots_signing", "radroots_sql_core", "radroots_storage", "radroots_storage_indexeddb", "radroots_storage_sqlite", "radroots_sync", "radroots_test_fixtures", "radroots_trade", "radroots_trade_bindings", "radroots_transport", "radroots_transport_nostr", "radroots_transport_nostr_browser", "radroots_transport_nostr_native", "radroots_transport_reticulum", "xtask"]
reserved_packages = []
[[group]]
@@ -45,6 +45,6 @@ reserved_packages = []
[[group]]
id = "wasm"
-packages = ["radroots_event_codec_wasm", "radroots_replica_store_wasm", "radroots_replica_sync_wasm", "radroots_sdk_sql_wasm_runtime", "radroots_sql_core", "radroots_storage_indexeddb"]
-active_packages = ["radroots_event_codec_wasm", "radroots_replica_store_wasm", "radroots_replica_sync_wasm", "radroots_sdk_sql_wasm_runtime", "radroots_sql_core", "radroots_storage_indexeddb"]
+packages = ["radroots_event_codec_wasm", "radroots_replica_store_wasm", "radroots_replica_sync_wasm", "radroots_sdk_sql_wasm_runtime", "radroots_sql_core", "radroots_storage_indexeddb", "radroots_transport_nostr_browser"]
+active_packages = ["radroots_event_codec_wasm", "radroots_replica_store_wasm", "radroots_replica_sync_wasm", "radroots_sdk_sql_wasm_runtime", "radroots_sql_core", "radroots_storage_indexeddb", "radroots_transport_nostr_browser"]
reserved_packages = []
diff --git a/contracts/crates/generated/platform_inventory.v1.toml b/contracts/crates/generated/platform_inventory.v1.toml
@@ -1,5 +1,5 @@
schema = "radroots.workspace.platform-inventory.v1"
-catalog_sha256 = "9dc291f170c1888cd2f9e9acb10c1251e32dd7b94c9b3c347feb7a6eaa44b475"
+catalog_sha256 = "00210ad66c7305d5e57f24e821a0c215e8bd9db25a1382490d6710aca88d3650"
[[platform]]
id = "any"
@@ -11,4 +11,4 @@ packages = ["radroots_core_bindings", "radroots_event_bindings", "radroots_geona
[[platform]]
id = "wasm32"
-packages = ["radroots_event_codec_wasm", "radroots_replica_store_wasm", "radroots_replica_sync_wasm", "radroots_sdk_sql_wasm_runtime", "radroots_sql_core", "radroots_storage_indexeddb", "radroots_transport_nostr"]
+packages = ["radroots_event_codec_wasm", "radroots_replica_store_wasm", "radroots_replica_sync_wasm", "radroots_sdk_sql_wasm_runtime", "radroots_sql_core", "radroots_storage_indexeddb", "radroots_transport_nostr", "radroots_transport_nostr_browser"]
diff --git a/contracts/crates/generated/release_inventory.v2.toml b/contracts/crates/generated/release_inventory.v2.toml
@@ -1,7 +1,7 @@
schema = "radroots.workspace.release-inventory.v2"
-catalog_sha256 = "9dc291f170c1888cd2f9e9acb10c1251e32dd7b94c9b3c347feb7a6eaa44b475"
+catalog_sha256 = "00210ad66c7305d5e57f24e821a0c215e8bd9db25a1382490d6710aca88d3650"
architecture = "radroots.crates.release.v2"
version = "0.1.0-alpha"
public_packages = ["radroots", "radroots_blossom", "radroots_core", "radroots_domain", "radroots_event", "radroots_event_codec", "radroots_execution", "radroots_geonames", "radroots_identity", "radroots_nostr", "radroots_nostr_connect", "radroots_protocol", "radroots_sdk", "radroots_secrets", "radroots_signing", "radroots_storage", "radroots_storage_sqlite", "radroots_sync", "radroots_trade", "radroots_transport", "radroots_transport_nostr", "radroots_transport_nostr_native"]
-private_packages = ["radroots_core_bindings", "radroots_event_bindings", "radroots_event_codec_wasm", "radroots_identity_bindings", "radroots_mesh", "radroots_mesh_agent_client", "radroots_mesh_agent_proto", "radroots_nostrdb", "radroots_replica_schema", "radroots_replica_schema_bindings", "radroots_replica_store", "radroots_replica_store_wasm", "radroots_replica_sync", "radroots_replica_sync_wasm", "radroots_runtime_distribution", "radroots_runtime_manager", "radroots_runtime_paths", "radroots_sdk_ffi", "radroots_sdk_sql_wasm_runtime", "radroots_service_host", "radroots_service_sqlite", "radroots_simplex_agent_proto", "radroots_simplex_app_store", "radroots_simplex_chat_proto", "radroots_simplex_smp_crypto", "radroots_simplex_smp_proto", "radroots_simplex_smp_transport", "radroots_sql_core", "radroots_storage_indexeddb", "radroots_test_fixtures", "radroots_trade_bindings", "radroots_transport_reticulum", "xtask"]
+private_packages = ["radroots_core_bindings", "radroots_event_bindings", "radroots_event_codec_wasm", "radroots_identity_bindings", "radroots_mesh", "radroots_mesh_agent_client", "radroots_mesh_agent_proto", "radroots_nostrdb", "radroots_replica_schema", "radroots_replica_schema_bindings", "radroots_replica_store", "radroots_replica_store_wasm", "radroots_replica_sync", "radroots_replica_sync_wasm", "radroots_runtime_distribution", "radroots_runtime_manager", "radroots_runtime_paths", "radroots_sdk_ffi", "radroots_sdk_sql_wasm_runtime", "radroots_service_host", "radroots_service_sqlite", "radroots_simplex_agent_proto", "radroots_simplex_app_store", "radroots_simplex_chat_proto", "radroots_simplex_smp_crypto", "radroots_simplex_smp_proto", "radroots_simplex_smp_transport", "radroots_sql_core", "radroots_storage_indexeddb", "radroots_test_fixtures", "radroots_trade_bindings", "radroots_transport_nostr_browser", "radroots_transport_reticulum", "xtask"]
reserved_packages = []
diff --git a/contracts/releases/publish_policy.toml b/contracts/releases/publish_policy.toml
@@ -66,6 +66,7 @@ private = [
"radroots_service_sqlite",
"radroots_sql_core",
"radroots_storage_indexeddb",
+ "radroots_transport_nostr_browser",
]
build_codegen = [
"radroots_core_bindings",
diff --git a/crates/transport_nostr_browser/Cargo.toml b/crates/transport_nostr_browser/Cargo.toml
@@ -0,0 +1,29 @@
+[package]
+name = "radroots_transport_nostr_browser"
+publish = false
+version = "0.1.0-alpha"
+edition.workspace = true
+rust-version.workspace = true
+authors.workspace = true
+license.workspace = true
+repository.workspace = true
+homepage.workspace = true
+description = "Bounded browser sockets for the shared Radroots Nostr session"
+readme = "README.md"
+
+[dependencies]
+radroots_transport = { workspace = true, features = ["std"] }
+radroots_transport_nostr = { workspace = true }
+futures = { workspace = true }
+url = { workspace = true }
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+async-utility = { workspace = true }
+js-sys = { workspace = true }
+wasm-bindgen = { workspace = true }
+wasm-bindgen-futures = { workspace = true }
+web-time = { workspace = true }
+web-sys = { workspace = true, features = ["BinaryType", "CloseEvent", "Event", "EventTarget", "MessageEvent", "WebSocket"] }
+
+[lints]
+workspace = true
diff --git a/crates/transport_nostr_browser/README.md b/crates/transport_nostr_browser/README.md
@@ -0,0 +1,35 @@
+# radroots_transport_nostr_browser
+
+Origin-thread WebSocket I/O for the existing shared Radroots Nostr session.
+`BrowserConnector` is inert; `create_transport` selects this concrete provider.
+DOM objects and callbacks remain in one local owner. Cross-boundary futures
+contain only owned Rust data and safe channels. There is no second relay pool.
+
+Received messages are limited to 512 KiB, 256 queued messages and 4 MiB of
+queued payload. The original connection admission charges each delivered
+message before exposing it to the shared decoder. Refusal closes this socket
+and reports an error. Outgoing messages are serialized, bounded, and refused
+when the browser's reported buffered amount would exceed 4 MiB. A successful
+send means local browser enqueue only; protocol acceptance remains owned by
+the shared session. Binary and text remain distinct and unchanged.
+
+The browser owns DNS, TLS, WebSocket framing, control frames and allocations
+before callbacks. This provider cannot pin DNS results, meter plaintext before
+decode, observe wire fragmentation or bound the user agent's internal buffers.
+It checks literal IP destinations against admission and relies on the shared
+explicit URL policy for configured DNS names. Its byte/work charges describe
+delivered payload and message starts, not native wire framing. Ping/pong are
+unsupported. User-agent error objects and close reasons are not diagnostics.
+Use `Socket::close` for local close; sending a control-frame variant is refused.
+
+The pinned upstream session requires one compile-time time-provider selection
+in a final WASM artifact. That artifact root must bind the provider to real
+browser monotonic and wall clocks. This library exports no global provider
+symbol. The source-owned browser I/O fixture makes this artifact-root choice
+explicitly; it does not use a simulated clock.
+
+Explicit close waits for local callback detachment and socket close initiation;
+it does not prove a remote close handshake. Cancelling a connect or dropping the
+last socket handle requests that same local cleanup. A page or worker being
+terminated has no asynchronous completion guarantee. Import and construction
+perform no I/O. Non-browser targets refuse connections.
diff --git a/crates/transport_nostr_browser/src/browser.rs b/crates/transport_nostr_browser/src/browser.rs
@@ -0,0 +1,357 @@
+use crate::state::{MAX_QUEUE_BYTES, SendRequest, Shared, Status, payload_len};
+use futures::{
+ channel::oneshot,
+ future::{Either, poll_fn, select},
+ lock::Mutex,
+};
+use radroots_transport::host::websocket::{Admission, Error, Frame, IoFuture, Socket};
+use std::{num::NonZeroUsize, pin::pin, sync::Arc, task::Poll, time::Duration};
+use wasm_bindgen::{JsCast, closure::Closure};
+use web_sys::{BinaryType, Event, MessageEvent, WebSocket};
+use web_time::Instant;
+
+pub(crate) async fn connect(
+ endpoint: &str,
+ timeout: Duration,
+ limit: NonZeroUsize,
+ admission: Arc<dyn Admission>,
+) -> Result<Arc<dyn Socket>, Error> {
+ poll_fn(|context| {
+ Poll::Ready(
+ if admission.admitted_read(context) && admission.admitted_write(context) {
+ Ok(())
+ } else {
+ Err(Error::Policy)
+ },
+ )
+ })
+ .await?;
+ let shared = Arc::new(Shared::new(admission, limit.get()));
+ let (sender, receiver) = oneshot::channel();
+ let mut cancellation = CancelConnect(Some(shared.clone()));
+ start_owner(
+ endpoint.to_owned(),
+ Instant::now() + timeout,
+ shared,
+ sender,
+ );
+ let result = receiver.await.unwrap_or(Err(Error::Closed));
+ if result.is_ok() {
+ cancellation.0.take();
+ }
+ result
+}
+
+struct CancelConnect(Option<Arc<Shared>>);
+impl Drop for CancelConnect {
+ fn drop(&mut self) {
+ if let Some(shared) = &self.0 {
+ shared.stop();
+ }
+ }
+}
+
+// This synchronous handoff is the only place the Send future touches the local
+// executor. The spawned future, DOM values and callbacks never leave it.
+fn start_owner(
+ endpoint: String,
+ deadline: Instant,
+ shared: Arc<Shared>,
+ ready: oneshot::Sender<Result<Arc<dyn Socket>, Error>>,
+) {
+ wasm_bindgen_futures::spawn_local(async move {
+ let result = poll_fn(|context| {
+ // The local owner may start after the original caller yielded.
+ // Recheck the original grant before constructing the DOM socket.
+ if !shared.admission.admitted_read(context) || !shared.admission.admitted_write(context)
+ {
+ return Poll::Ready(Err(Error::Policy));
+ }
+ Poll::Ready(Owner::open(&endpoint, shared.clone(), deadline))
+ })
+ .await;
+ let mut owner = match result {
+ Ok(owner) => owner,
+ Err(error) => {
+ shared.fail(error);
+ shared.finish();
+ let _ = ready.send(Err(error));
+ return;
+ }
+ };
+ let opening = poll_fn(|context| {
+ shared.actor.register(context.waker());
+ if !shared.admission.admitted_read(context) || !shared.admission.admitted_write(context)
+ {
+ return Poll::Ready(Err(Error::Policy));
+ }
+ let state = shared.lock()?;
+ Poll::Ready(match state.status {
+ Status::Open if !state.stopping => Ok(()),
+ Status::Failed(error) => Err(error),
+ Status::Ended => Err(Error::Closed),
+ _ if state.stopping => Err(Error::Closed),
+ _ => return Poll::Pending,
+ })
+ });
+ let opened = match select(pin!(opening), pin!(sleep_until(deadline))).await {
+ Either::Left((result, _)) => result,
+ Either::Right(_) => Err(Error::Timeout),
+ };
+ if let Err(error) = opened {
+ shared.fail(error);
+ let _ = ready.send(Err(error));
+ return;
+ }
+ let socket: Arc<dyn Socket> = Arc::new(BrowserSocket {
+ shared: shared.clone(),
+ sending: Mutex::new(()),
+ receiving: Mutex::new(()),
+ closing: Mutex::new(()),
+ });
+ if ready.send(Ok(socket)).is_err() {
+ return;
+ }
+ owner.drive().await;
+ });
+}
+
+async fn sleep_until(deadline: Instant) {
+ loop {
+ let remaining = deadline.saturating_duration_since(Instant::now());
+ if remaining.is_zero() {
+ return;
+ }
+ let millis = remaining
+ .as_nanos()
+ .div_ceil(1_000_000)
+ .min(i32::MAX as u128) as u64;
+ async_utility::time::sleep(Duration::from_millis(millis)).await;
+ }
+}
+
+struct BrowserSocket {
+ shared: Arc<Shared>,
+ sending: Mutex<()>,
+ receiving: Mutex<()>,
+ closing: Mutex<()>,
+}
+
+impl Drop for BrowserSocket {
+ fn drop(&mut self) {
+ self.shared.stop();
+ }
+}
+
+impl Socket for BrowserSocket {
+ fn send(&self, frame: Frame) -> IoFuture<'_, Result<(), Error>> {
+ Box::pin(async move {
+ let bytes = payload_len(&frame)?;
+ if bytes > self.shared.limit {
+ return Err(Error::Protocol);
+ }
+ let _guard = self.sending.lock().await;
+ let (sender, receiver) = oneshot::channel();
+ {
+ let mut state = self.shared.lock()?;
+ if state.stopping || state.status != Status::Open {
+ return Err(Error::Closed);
+ }
+ // Cancellation of a send observer does not erase admitted I/O.
+ if state.outgoing.is_some() {
+ return Err(Error::Policy);
+ }
+ state.outgoing = Some(SendRequest {
+ frame,
+ result: sender,
+ });
+ }
+ self.shared.actor.wake();
+ receiver.await.unwrap_or(Err(Error::Closed))
+ })
+ }
+
+ fn receive(&self) -> IoFuture<'_, Result<Option<Frame>, Error>> {
+ Box::pin(async move {
+ let _guard = self.receiving.lock().await;
+ poll_fn(|context| {
+ self.shared.reader.register(context.waker());
+ if !self.shared.admission.admitted_read(context) {
+ self.shared.fail(Error::Policy);
+ return Poll::Ready(Err(Error::Policy));
+ }
+ if let Some(frame) = self.shared.pop()? {
+ return Poll::Ready(Ok(Some(frame)));
+ }
+ let state = self.shared.lock()?;
+ if state.finished || state.stopping || state.status == Status::Ended {
+ Poll::Ready(Ok(None))
+ } else {
+ Poll::Pending
+ }
+ })
+ .await
+ })
+ }
+
+ fn close(&self) -> IoFuture<'_, Result<(), Error>> {
+ Box::pin(async move {
+ let _guard = self.closing.lock().await;
+ self.shared.stop();
+ poll_fn(|context| {
+ self.shared.closer.register(context.waker());
+ if self.shared.lock()?.finished {
+ Poll::Ready(Ok(()))
+ } else {
+ Poll::Pending
+ }
+ })
+ .await
+ })
+ }
+}
+
+struct Owner {
+ socket: WebSocket,
+ shared: Arc<Shared>,
+ _open: Closure<dyn FnMut(Event)>,
+ _message: Closure<dyn FnMut(MessageEvent)>,
+ _error: Closure<dyn FnMut(Event)>,
+ _close: Closure<dyn FnMut(Event)>,
+}
+
+impl Owner {
+ fn open(endpoint: &str, shared: Arc<Shared>, deadline: Instant) -> Result<Self, Error> {
+ if shared.lock()?.stopping {
+ return Err(Error::Closed);
+ }
+ if Instant::now() >= deadline {
+ return Err(Error::Timeout);
+ }
+ let socket = WebSocket::new(endpoint).map_err(|_| Error::Unavailable)?;
+ socket.set_binary_type(BinaryType::Arraybuffer);
+ let state = shared.clone();
+ let open = Closure::new(move |_: Event| {
+ if let Ok(mut inner) = state.lock()
+ && inner.status == Status::Connecting
+ && !inner.stopping
+ {
+ inner.status = Status::Open;
+ }
+ state.wake();
+ });
+ let state = shared.clone();
+ let message = Closure::new(move |event: MessageEvent| {
+ let frame = decode_message(event, state.limit).and_then(|frame| state.push(frame));
+ if let Err(error) = frame {
+ state.fail(error);
+ }
+ });
+ let state = shared.clone();
+ let error = Closure::new(move |_: Event| state.fail(Error::Unavailable));
+ let state = shared.clone();
+ let close = Closure::new(move |_: Event| {
+ if let Ok(mut inner) = state.lock()
+ && !matches!(inner.status, Status::Failed(_))
+ {
+ inner.status = Status::Ended;
+ }
+ state.wake();
+ });
+ socket.set_onopen(Some(open.as_ref().unchecked_ref()));
+ socket.set_onmessage(Some(message.as_ref().unchecked_ref()));
+ socket.set_onerror(Some(error.as_ref().unchecked_ref()));
+ socket.set_onclose(Some(close.as_ref().unchecked_ref()));
+ Ok(Self {
+ socket,
+ shared,
+ _open: open,
+ _message: message,
+ _error: error,
+ _close: close,
+ })
+ }
+
+ async fn drive(&mut self) {
+ poll_fn(|context| {
+ self.shared.actor.register(context.waker());
+ if !self.shared.admission.admitted_read(context)
+ || !self.shared.admission.admitted_write(context)
+ {
+ self.shared.fail(Error::Policy);
+ }
+ let request = {
+ let mut state = match self.shared.lock() {
+ Ok(state) => state,
+ Err(_) => return Poll::Ready(()),
+ };
+ if state.stopping || state.status != Status::Open {
+ return Poll::Ready(());
+ }
+ state.outgoing.take()
+ };
+ if let Some(request) = request {
+ let result = self.send(request.frame);
+ if let Err(error) = result {
+ self.shared.fail(error);
+ }
+ let _ = request.result.send(result);
+ if result.is_err() {
+ return Poll::Ready(());
+ }
+ }
+ Poll::Pending
+ })
+ .await;
+ }
+
+ fn send(&self, frame: Frame) -> Result<(), Error> {
+ let bytes = payload_len(&frame)?;
+ if bytes > self.shared.limit {
+ return Err(Error::Protocol);
+ }
+ if u64::from(self.socket.buffered_amount()) + bytes as u64 > MAX_QUEUE_BYTES as u64 {
+ return Err(Error::Policy);
+ }
+ match frame {
+ Frame::Text(text) => self.socket.send_with_str(&text),
+ Frame::Binary(bytes) => self.socket.send_with_u8_array(&bytes),
+ _ => return Err(Error::Unsupported),
+ }
+ .map_err(|_| Error::Unavailable)
+ }
+}
+
+impl Drop for Owner {
+ fn drop(&mut self) {
+ self.socket.set_onopen(None);
+ self.socket.set_onmessage(None);
+ self.socket.set_onerror(None);
+ self.socket.set_onclose(None);
+ let _ = self.socket.close();
+ self.shared.finish();
+ }
+}
+
+fn decode_message(event: MessageEvent, limit: usize) -> Result<Frame, Error> {
+ let data = event.data();
+ if data.is_string() {
+ let value: js_sys::JsString = data.unchecked_into();
+ if value.length() as usize > limit {
+ return Err(Error::Protocol);
+ }
+ let text: String = value.into();
+ if text.len() > limit {
+ return Err(Error::Protocol);
+ }
+ Ok(Frame::Text(text))
+ } else if data.is_instance_of::<js_sys::ArrayBuffer>() {
+ let buffer: js_sys::ArrayBuffer = data.unchecked_into();
+ if buffer.byte_length() as usize > limit {
+ return Err(Error::Protocol);
+ }
+ Ok(Frame::Binary(js_sys::Uint8Array::new(&buffer).to_vec()))
+ } else {
+ Err(Error::Protocol)
+ }
+}
diff --git a/crates/transport_nostr_browser/src/connector.rs b/crates/transport_nostr_browser/src/connector.rs
@@ -0,0 +1,123 @@
+use radroots_transport::host::websocket::{Admission, Connector, Error, IoFuture, Socket};
+use std::{net::IpAddr, num::NonZeroUsize, sync::Arc, time::Duration};
+
+/// Inert provider whose DOM socket and callbacks stay on their origin thread.
+#[derive(Clone, Copy, Debug, Default)]
+pub struct BrowserConnector;
+
+impl Connector for BrowserConnector {
+ fn supports_ping(&self) -> bool {
+ false
+ }
+
+ fn connect<'a>(
+ &'a self,
+ endpoint: &'a str,
+ timeout: Duration,
+ max_message_bytes: NonZeroUsize,
+ admission: Arc<dyn Admission>,
+ ) -> IoFuture<'a, Result<Arc<dyn Socket>, Error>> {
+ Box::pin(async move {
+ validate_endpoint(endpoint, admission.as_ref())?;
+ if timeout.is_zero() {
+ return Err(Error::Timeout);
+ }
+ #[cfg(target_arch = "wasm32")]
+ {
+ crate::browser::connect(endpoint, timeout, max_message_bytes, admission).await
+ }
+ #[cfg(not(target_arch = "wasm32"))]
+ {
+ let _ = max_message_bytes;
+ Err(Error::Unsupported)
+ }
+ })
+ }
+}
+
+fn validate_endpoint(endpoint: &str, admission: &dyn Admission) -> Result<(), Error> {
+ let url = url::Url::parse(endpoint).map_err(|_| Error::Policy)?;
+ if !matches!(url.scheme(), "ws" | "wss")
+ || !url.username().is_empty()
+ || url.password().is_some()
+ || url.fragment().is_some()
+ {
+ return Err(Error::Policy);
+ }
+ let host = url
+ .host_str()
+ .ok_or(Error::Policy)?
+ .trim_matches(['[', ']']);
+ if let Ok(address) = host.parse::<IpAddr>()
+ && !admission.permits_address(address)
+ {
+ return Err(Error::Policy);
+ }
+ Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::state::tests::AdmissionCounter as Grant;
+ #[test]
+ fn endpoint_validation_is_explicit_and_never_resolves_dns() {
+ for endpoint in [
+ "invalid",
+ "https://example.org",
+ "ws://a:b@example.org",
+ "wss://example.org/#fragment",
+ ] {
+ assert_eq!(
+ validate_endpoint(endpoint, Grant::new(true).as_ref()),
+ Err(Error::Policy)
+ );
+ }
+ for endpoint in ["ws://127.0.0.1", "wss://[::1]"] {
+ assert_eq!(
+ validate_endpoint(endpoint, Grant::new(false).as_ref()),
+ Err(Error::Policy)
+ );
+ assert_eq!(
+ validate_endpoint(endpoint, Grant::new(true).as_ref()),
+ Ok(())
+ );
+ }
+ assert_eq!(
+ validate_endpoint("wss://relay.example/path?q=1", Grant::new(false).as_ref()),
+ Ok(())
+ );
+ }
+ #[test]
+ fn non_browser_connection_refuses_and_zero_deadline_does_not_start_io() {
+ assert!(!BrowserConnector.supports_ping());
+ for (endpoint, duration, error) in [
+ ("ws://127.0.0.1", Duration::from_secs(1), Error::Unsupported),
+ ("wss://example.org", Duration::ZERO, Error::Timeout),
+ ("invalid", Duration::from_secs(1), Error::Policy),
+ ] {
+ let result = futures::executor::block_on(BrowserConnector.connect(
+ endpoint,
+ duration,
+ NonZeroUsize::new(1).unwrap(),
+ Grant::new(true),
+ ));
+ assert!(matches!(result, Err(found) if found == error));
+ }
+ }
+
+ #[test]
+ fn factory_constructs_the_shared_session_without_host_effects() {
+ use radroots_transport_nostr::{
+ Config, RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind, RelayUrlPolicy,
+ };
+ let endpoint = RelayEndpoint::new(
+ "wss://relay.example",
+ RelayUrlPolicy::Public,
+ RelayAccess::ReadWrite,
+ )
+ .unwrap();
+ let profile = RelayProfile::explicit(RelayProfileKind::Public, [endpoint]).unwrap();
+ let _transport = crate::create_transport(Config::from_profile(profile));
+ }
+}
diff --git a/crates/transport_nostr_browser/src/lib.rs b/crates/transport_nostr_browser/src/lib.rs
@@ -0,0 +1,19 @@
+#![doc = include_str!("../README.md")]
+#![forbid(unsafe_code)]
+#![cfg_attr(coverage_nightly, feature(coverage_attribute))]
+
+#[cfg(target_arch = "wasm32")]
+mod browser;
+mod connector;
+#[cfg(any(target_arch = "wasm32", test))]
+mod state;
+
+pub use connector::BrowserConnector;
+
+/// Composes the shared Nostr session with origin-thread browser socket I/O.
+/// Construction performs no I/O and spawns no task.
+pub fn create_transport(
+ config: radroots_transport_nostr::Config,
+) -> radroots_transport_nostr::NostrTransport {
+ radroots_transport_nostr::NostrTransport::new(config, std::sync::Arc::new(BrowserConnector))
+}
diff --git a/crates/transport_nostr_browser/src/state.rs b/crates/transport_nostr_browser/src/state.rs
@@ -0,0 +1,164 @@
+//! Bounded owned data only. No JavaScript values cross this boundary.
+
+use futures::{channel::oneshot, task::AtomicWaker};
+use radroots_transport::host::websocket::{Admission, Error, Frame};
+use std::{
+ collections::VecDeque,
+ sync::{Arc, Mutex, MutexGuard},
+};
+
+pub(crate) const MAX_MESSAGE: usize = 512 * 1024;
+pub(crate) const MAX_QUEUE_BYTES: usize = 4 * 1024 * 1024;
+pub(crate) const MAX_QUEUE_MESSAGES: usize = 256;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum Status {
+ Connecting,
+ Open,
+ Ended,
+ Failed(Error),
+}
+
+pub(crate) struct SendRequest {
+ pub(crate) frame: Frame,
+ pub(crate) result: oneshot::Sender<Result<(), Error>>,
+}
+
+pub(crate) struct State {
+ pub(crate) status: Status,
+ pub(crate) stopping: bool,
+ pub(crate) finished: bool,
+ pub(crate) outgoing: Option<SendRequest>,
+ incoming: VecDeque<Frame>,
+ bytes: usize,
+}
+
+impl State {
+ fn check_enqueue(&self, bytes: usize, limit: usize) -> Result<(), Error> {
+ if self.stopping || self.status != Status::Open {
+ return Err(Error::Closed);
+ }
+ if bytes > limit
+ || self.incoming.len() >= MAX_QUEUE_MESSAGES
+ || bytes > MAX_QUEUE_BYTES.saturating_sub(self.bytes)
+ {
+ return Err(Error::Policy);
+ }
+ Ok(())
+ }
+}
+
+pub(crate) struct Shared {
+ state: Mutex<State>,
+ pub(crate) admission: Arc<dyn Admission>,
+ pub(crate) limit: usize,
+ pub(crate) actor: AtomicWaker,
+ pub(crate) reader: AtomicWaker,
+ pub(crate) closer: AtomicWaker,
+}
+
+impl Shared {
+ pub(crate) fn new(admission: Arc<dyn Admission>, limit: usize) -> Self {
+ Self {
+ state: Mutex::new(State {
+ status: Status::Connecting,
+ stopping: false,
+ finished: false,
+ outgoing: None,
+ incoming: VecDeque::new(),
+ bytes: 0,
+ }),
+ admission,
+ limit: limit.min(MAX_MESSAGE),
+ actor: AtomicWaker::new(),
+ reader: AtomicWaker::new(),
+ closer: AtomicWaker::new(),
+ }
+ }
+
+ pub(crate) fn lock(&self) -> Result<MutexGuard<'_, State>, Error> {
+ self.state.lock().map_err(|_| Error::Closed)
+ }
+
+ pub(crate) fn wake(&self) {
+ self.actor.wake();
+ self.reader.wake();
+ self.closer.wake();
+ }
+
+ pub(crate) fn stop(&self) {
+ if let Ok(mut state) = self.lock() {
+ state.stopping = true;
+ }
+ self.wake();
+ }
+
+ pub(crate) fn fail(&self, error: Error) {
+ if let Ok(mut state) = self.lock() {
+ // The first refusal remains authoritative through later callbacks.
+ if !matches!(state.status, Status::Failed(_)) {
+ state.status = Status::Failed(error);
+ }
+ state.incoming.clear();
+ state.bytes = 0;
+ }
+ self.wake();
+ }
+
+ pub(crate) fn push(&self, frame: Frame) -> Result<(), Error> {
+ let bytes = payload_len(&frame)?;
+ self.lock()?.check_enqueue(bytes, self.limit)?;
+ // Admission may wake or cancel an observer. Call it without our lock,
+ // then revalidate closure and queue credit before exposing the frame.
+ if !self.admission.charge(bytes, 1, 1) {
+ return Err(Error::Policy);
+ }
+ let mut state = self.lock()?;
+ state.check_enqueue(bytes, self.limit)?;
+ state.bytes += bytes;
+ state.incoming.push_back(frame);
+ drop(state);
+ self.wake();
+ Ok(())
+ }
+
+ pub(crate) fn pop(&self) -> Result<Option<Frame>, Error> {
+ let mut state = self.lock()?;
+ if let Status::Failed(error) = state.status {
+ return Err(error);
+ }
+ let frame = state.incoming.pop_front();
+ if let Some(frame) = &frame {
+ state.bytes -= payload_len(frame)?;
+ }
+ Ok(frame)
+ }
+
+ pub(crate) fn finish(&self) {
+ let outgoing = if let Ok(mut state) = self.lock() {
+ state.finished = true;
+ if !matches!(state.status, Status::Failed(_)) {
+ state.status = Status::Ended;
+ }
+ state.outgoing.take()
+ } else {
+ None
+ };
+ if let Some(request) = outgoing {
+ let _ = request.result.send(Err(Error::Closed));
+ }
+ self.wake();
+ }
+}
+
+pub(crate) fn payload_len(frame: &Frame) -> Result<usize, Error> {
+ match frame {
+ Frame::Text(text) => Ok(text.len()),
+ Frame::Binary(bytes) => Ok(bytes.len()),
+ _ => Err(Error::Unsupported),
+ }
+}
+
+#[cfg(test)]
+#[path = "state_tests.rs"]
+pub(crate) mod tests;
diff --git a/crates/transport_nostr_browser/src/state_tests.rs b/crates/transport_nostr_browser/src/state_tests.rs
@@ -0,0 +1,240 @@
+use super::*;
+use std::{
+ net::IpAddr,
+ sync::atomic::{AtomicBool, AtomicUsize, Ordering},
+ task::Context,
+};
+
+pub(crate) struct AdmissionCounter {
+ allow: AtomicBool,
+ bytes: AtomicUsize,
+ frames: AtomicUsize,
+ cancelling: Mutex<Option<std::sync::Weak<Shared>>>,
+}
+impl AdmissionCounter {
+ pub(crate) fn new(allow: bool) -> Arc<Self> {
+ Arc::new(Self {
+ allow: AtomicBool::new(allow),
+ bytes: AtomicUsize::new(0),
+ frames: AtomicUsize::new(0),
+ cancelling: Mutex::new(None),
+ })
+ }
+}
+impl Admission for AdmissionCounter {
+ fn permits_address(&self, _: IpAddr) -> bool {
+ self.allow.load(Ordering::SeqCst)
+ }
+ fn admitted_read(&self, _: &Context<'_>) -> bool {
+ self.allow.load(Ordering::SeqCst)
+ }
+ fn admitted_write(&self, _: &Context<'_>) -> bool {
+ self.allow.load(Ordering::SeqCst)
+ }
+ fn charge(&self, bytes: usize, frames: usize, data: usize) -> bool {
+ assert_eq!(frames, data);
+ self.bytes.fetch_add(bytes, Ordering::SeqCst);
+ self.frames.fetch_add(frames, Ordering::SeqCst);
+ let cancelling = self.cancelling.lock().unwrap().clone();
+ if let Some(shared) = cancelling.and_then(|weak| weak.upgrade()) {
+ // Fail promptly rather than deadlocking the regression if a host
+ // calls the admission callback while holding its own state lock.
+ if shared.state.try_lock().is_err() {
+ return false;
+ }
+ shared.stop();
+ }
+ self.allow.load(Ordering::SeqCst)
+ }
+}
+fn shared(limit: usize) -> (Shared, Arc<AdmissionCounter>) {
+ let admission = AdmissionCounter::new(true);
+ (Shared::new(admission.clone(), limit), admission)
+}
+fn open(limit: usize) -> (Shared, Arc<AdmissionCounter>) {
+ let result = shared(limit);
+ result.0.lock().unwrap().status = Status::Open;
+ result
+}
+
+#[test]
+fn original_binary_and_text_are_charged_once_and_dequeue_releases_bytes() {
+ let (shared, admission) = open(64);
+ assert_eq!(shared.pop(), Ok(None));
+ let frames = [
+ Frame::Text(" [\"raw\", 3] ".into()),
+ Frame::Binary(vec![0, 255, 12]),
+ ];
+ for frame in &frames {
+ shared.push(frame.clone()).unwrap();
+ }
+ assert_eq!(admission.bytes.load(Ordering::SeqCst), 16);
+ assert_eq!(admission.frames.load(Ordering::SeqCst), 2);
+ for frame in frames {
+ assert_eq!(shared.pop(), Ok(Some(frame)));
+ }
+ assert_eq!(shared.lock().unwrap().bytes, 0);
+}
+
+#[test]
+fn item_limit_counts_empty_messages_and_never_charges_rejected_queue_work() {
+ let (shared, admission) = open(1);
+ for _ in 0..MAX_QUEUE_MESSAGES {
+ shared.push(Frame::Text(String::new())).unwrap();
+ }
+ assert_eq!(shared.push(Frame::Binary(vec![])), Err(Error::Policy));
+ assert_eq!(admission.frames.load(Ordering::SeqCst), MAX_QUEUE_MESSAGES);
+ assert_eq!(shared.pop(), Ok(Some(Frame::Text(String::new()))));
+ shared.push(Frame::Binary(vec![])).unwrap();
+}
+
+#[test]
+fn byte_limit_is_exact_and_newly_freed_credit_is_reusable() {
+ let (shared, _) = open(MAX_MESSAGE);
+ for _ in 0..8 {
+ shared.push(Frame::Binary(vec![7; MAX_MESSAGE])).unwrap();
+ }
+ assert_eq!(shared.lock().unwrap().bytes, MAX_QUEUE_BYTES);
+ assert_eq!(shared.push(Frame::Text("x".into())), Err(Error::Policy));
+ shared.pop().unwrap();
+ shared.push(Frame::Binary(vec![9; MAX_MESSAGE])).unwrap();
+ assert_eq!(shared.lock().unwrap().bytes, MAX_QUEUE_BYTES);
+}
+
+#[test]
+fn message_limit_and_control_frames_refuse_before_charging() {
+ let (shared, admission) = open(2);
+ assert_eq!(shared.push(Frame::Text("abc".into())), Err(Error::Policy));
+ assert_eq!(shared.push(Frame::Ping(vec![])), Err(Error::Unsupported));
+ assert_eq!(shared.push(Frame::Pong(vec![])), Err(Error::Unsupported));
+ assert_eq!(shared.push(Frame::Close(None)), Err(Error::Unsupported));
+ assert_eq!(admission.frames.load(Ordering::SeqCst), 0);
+ shared.push(Frame::Text("é".into())).unwrap();
+ assert_eq!(admission.bytes.load(Ordering::SeqCst), 2);
+ assert_eq!(Shared::new(admission, usize::MAX).limit, MAX_MESSAGE);
+}
+
+#[test]
+fn admission_refusal_never_exposes_the_original_payload() {
+ let (shared, admission) = open(4);
+ admission.allow.store(false, Ordering::SeqCst);
+ assert_eq!(shared.push(Frame::Text("deny".into())), Err(Error::Policy));
+ assert_eq!(shared.pop(), Ok(None));
+ assert_eq!(admission.bytes.load(Ordering::SeqCst), 4);
+}
+
+#[test]
+fn first_failure_survives_subsequent_failure_close_and_finish() {
+ let (shared, _) = open(4);
+ shared.push(Frame::Text("live".into())).unwrap();
+ shared.fail(Error::Policy);
+ shared.fail(Error::Unavailable);
+ shared.stop();
+ shared.finish();
+ shared.finish();
+ assert_eq!(shared.pop(), Err(Error::Policy));
+ let state = shared.lock().unwrap();
+ assert_eq!(state.status, Status::Failed(Error::Policy));
+ assert!(state.finished && state.stopping);
+ assert_eq!(state.bytes, 0);
+}
+
+#[test]
+fn graceful_finish_preserves_original_queued_frames_and_fails_pending_send() {
+ let (shared, _) = open(8);
+ shared.push(Frame::Binary(vec![1, 2, 3])).unwrap();
+ let (sender, receiver) = oneshot::channel();
+ shared.lock().unwrap().outgoing = Some(SendRequest {
+ frame: Frame::Text("send".into()),
+ result: sender,
+ });
+ assert_eq!(
+ shared.lock().unwrap().outgoing.as_ref().unwrap().frame,
+ Frame::Text("send".into())
+ );
+ shared.finish();
+ assert_eq!(
+ futures::executor::block_on(receiver),
+ Ok(Err(Error::Closed))
+ );
+ assert_eq!(shared.pop(), Ok(Some(Frame::Binary(vec![1, 2, 3]))));
+ assert_eq!(shared.pop(), Ok(None));
+ assert_eq!(shared.lock().unwrap().status, Status::Ended);
+}
+
+#[test]
+fn connecting_stopping_ended_and_failed_refuse_new_payloads() {
+ let (shared, _) = shared(4);
+ assert_eq!(shared.push(Frame::Text("x".into())), Err(Error::Closed));
+ for status in [Status::Ended, Status::Failed(Error::Policy)] {
+ shared.lock().unwrap().status = status;
+ assert_eq!(shared.push(Frame::Text("x".into())), Err(Error::Closed));
+ }
+ shared.lock().unwrap().status = Status::Open;
+ shared.stop();
+ assert_eq!(shared.push(Frame::Text("x".into())), Err(Error::Closed));
+}
+
+#[test]
+fn poisoned_state_refuses_and_cleanup_does_not_panic() {
+ let (shared, _) = shared(1);
+ let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+ let _guard = shared.state.lock().unwrap();
+ panic!("deliberate test poison");
+ }));
+ assert!(matches!(shared.lock(), Err(Error::Closed)));
+ assert_eq!(shared.push(Frame::Text("x".into())), Err(Error::Closed));
+ assert_eq!(shared.pop(), Err(Error::Closed));
+ shared.fail(Error::Policy);
+ shared.stop();
+ shared.finish();
+}
+
+#[test]
+fn admission_callback_can_cancel_before_a_frame_is_exposed() {
+ let admission = AdmissionCounter::new(true);
+ let shared = Arc::new(Shared::new(admission.clone(), 8));
+ *admission.cancelling.lock().unwrap() = Some(Arc::downgrade(&shared));
+ shared.lock().unwrap().status = Status::Open;
+ assert_eq!(
+ shared.push(Frame::Text("original".into())),
+ Err(Error::Closed)
+ );
+ assert_eq!(shared.pop(), Ok(None));
+}
+
+#[test]
+fn send_completion_wakes_its_observer_after_releasing_the_host_lock() {
+ use std::{future::Future, pin::Pin};
+ struct Observer {
+ shared: Arc<Shared>,
+ locked: AtomicBool,
+ }
+ impl futures::task::ArcWake for Observer {
+ fn wake_by_ref(this: &Arc<Self>) {
+ if this.shared.state.try_lock().is_err() {
+ this.locked.store(true, Ordering::SeqCst);
+ }
+ }
+ }
+ let (shared, _) = open(8);
+ let shared = Arc::new(shared);
+ let observer = Arc::new(Observer {
+ shared: shared.clone(),
+ locked: AtomicBool::new(false),
+ });
+ let waker = futures::task::waker(observer.clone());
+ let mut context = Context::from_waker(&waker);
+ let (sender, mut receiver) = oneshot::channel();
+ assert!(Pin::new(&mut receiver).poll(&mut context).is_pending());
+ shared.lock().unwrap().outgoing = Some(SendRequest {
+ frame: Frame::Text("original".into()),
+ result: sender,
+ });
+ shared.finish();
+ assert!(!observer.locked.load(Ordering::SeqCst));
+ assert_eq!(
+ futures::executor::block_on(receiver),
+ Ok(Err(Error::Closed))
+ );
+}
diff --git a/crates/transport_nostr_browser/tests/browser/Cargo.lock b/crates/transport_nostr_browser/tests/browser/Cargo.lock
@@ -0,0 +1,2613 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "addr2line"
+version = "0.25.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b5d307320b3181d6d7954e663bd7c774a838b8220fe0593c86d9fb09f498b4b"
+dependencies = [
+ "gimli",
+]
+
+[[package]]
+name = "adler2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
+
+[[package]]
+name = "aead"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0"
+dependencies = [
+ "crypto-common",
+ "generic-array",
+]
+
+[[package]]
+name = "aes"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
+dependencies = [
+ "cfg-if",
+ "cipher",
+ "cpufeatures",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
+
+[[package]]
+name = "arrayvec"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
+
+[[package]]
+name = "async-utility"
+version = "0.3.2"
+source = "git+https://github.com/yukibtc/async-utility?rev=b323ae0c1c1424b78bf8bb8832b95e86771f1dee#b323ae0c1c1424b78bf8bb8832b95e86771f1dee"
+dependencies = [
+ "futures-util",
+ "gloo-timers",
+ "tokio",
+ "wasm-bindgen-futures",
+]
+
+[[package]]
+name = "async-wsocket"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c713e1f14c7b82e32ea159af1c6e2f070cfadbdf23fb2512acce9af0a26f1a2"
+dependencies = [
+ "futures",
+ "futures-util",
+ "js-sys",
+ "tokio",
+ "tokio-happy-eyeballs",
+ "tokio-rustls",
+ "tokio-socks",
+ "tokio-tungstenite",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
+
+[[package]]
+name = "backtrace"
+version = "0.3.76"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb531853791a215d7c62a30daf0dde835f381ab5de4589cfe7c649d2cbe92bd6"
+dependencies = [
+ "addr2line",
+ "cfg-if",
+ "libc",
+ "miniz_oxide",
+ "object",
+ "rustc-demangle",
+ "windows-link",
+]
+
+[[package]]
+name = "base16ct"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
+
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
+[[package]]
+name = "base64ct"
+version = "1.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"
+
+[[package]]
+name = "bech32"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32637268377fc7b10a8c6d51de3e7fba1ce5dd371a96e342b34e6078db558e7f"
+
+[[package]]
+name = "bech32"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "efbd3e1070bbdf4cd88a75264e18e8a26f7cb5c6949eadf0ceb85fb159cf08f8"
+
+[[package]]
+name = "bip39"
+version = "2.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90dbd31c98227229239363921e60fcf5e558e43ec69094d46fc4996f08d1d5bc"
+dependencies = [
+ "bitcoin_hashes 0.14.1",
+ "serde",
+ "unicode-normalization",
+]
+
+[[package]]
+name = "bitcoin-consensus-encoding"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9daa31138eb443d5751b207f3f64154e2bb09cd59960562ccc7a7112be38147f"
+dependencies = [
+ "bitcoin-internals 0.7.0",
+]
+
+[[package]]
+name = "bitcoin-internals"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d573f4cf32996a8dce612e4348cece65a241f1882ed594047c9ba348e8869fa5"
+
+[[package]]
+name = "bitcoin-internals"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8bea3a9f0cfece4564e37cb49a38cc245ca5184719e50d7d0dda3268722c4e2"
+
+[[package]]
+name = "bitcoin-io"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dee39a0ee5b4095224a0cfc6bf4cc1baf0f9624b96b367e53b66d974e51d953"
+
+[[package]]
+name = "bitcoin_hashes"
+version = "0.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26ec84b80c482df901772e931a9a681e26a1b9ee2302edeff23cb30328745c8b"
+dependencies = [
+ "bitcoin-io",
+ "hex-conservative 0.2.2",
+ "serde",
+]
+
+[[package]]
+name = "bitcoin_hashes"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5304e53726dbe5f93141535e102ed97b5bf4714fbecefdda8f9fb98d7fdaff0e"
+dependencies = [
+ "bitcoin-consensus-encoding",
+ "bitcoin-internals 0.6.0",
+ "hex-conservative 1.3.0",
+ "serde",
+]
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bitflags"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "block-padding"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8894febbff9f758034a5b8e12d87918f56dfc64a8e1fe757d65e29041538d93"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "bytes"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
+
+[[package]]
+name = "cbc"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26b52a9543ae338f279b96b0b9fed9c8093744685043739079ce85cd58f289a6"
+dependencies = [
+ "cipher",
+]
+
+[[package]]
+name = "cc"
+version = "1.2.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a0dd1ca384932ff3641c8718a02769f1698e7563dc6974ffd03346116310423"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "chacha20"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818"
+dependencies = [
+ "cfg-if",
+ "cipher",
+ "cpufeatures",
+]
+
+[[package]]
+name = "chacha20poly1305"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10cd79432192d1c0f4e1a0fef9527696cc039165d729fb41b3f4f4f354c2dc35"
+dependencies = [
+ "aead",
+ "chacha20",
+ "cipher",
+ "poly1305",
+ "zeroize",
+]
+
+[[package]]
+name = "cipher"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
+dependencies = [
+ "crypto-common",
+ "inout",
+ "zeroize",
+]
+
+[[package]]
+name = "const-oid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-bigint"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
+dependencies = [
+ "generic-array",
+ "rand_core 0.6.4",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "rand_core 0.6.4",
+ "typenum",
+]
+
+[[package]]
+name = "data-encoding"
+version = "2.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7a1e2f27636f116493b8b860f5546edb47c8d8f8ea73e1d2a20be88e28d1fea"
+
+[[package]]
+name = "defmt"
+version = "0.3.101"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4deef977660e373c458df605a913d4ab121db0ccd18d1ad6976dff7d37cddb53"
+dependencies = [
+ "defmt 1.2.0",
+]
+
+[[package]]
+name = "defmt"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4a0795ac740cb54d7b3775c9c17345f6aaecf884c01733b39d6017738e0e3e1"
+dependencies = [
+ "bitflags 1.3.2",
+ "defmt-macros",
+]
+
+[[package]]
+name = "defmt-macros"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "840bb056bd99c495c9188198a258ab787c79f306d864db3e6e8451442d6d8366"
+dependencies = [
+ "defmt-parser",
+ "proc-macro2",
+ "quote",
+ "syn 3.0.2",
+]
+
+[[package]]
+name = "defmt-parser"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71958f69fb2de856c5dd51ac9377e986ca1aa5919f931bf5395a807277f889a0"
+dependencies = [
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "der"
+version = "0.7.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb"
+dependencies = [
+ "const-oid",
+ "zeroize",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "elliptic-curve"
+version = "0.13.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"
+dependencies = [
+ "base16ct",
+ "crypto-bigint",
+ "ff",
+ "generic-array",
+ "group",
+ "rand_core 0.6.4",
+ "sec1",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "faster-hex"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04839bdf9d8c10f66806fad16b852fc72aab80873aebc3cb69d85b4fa41543ed"
+dependencies = [
+ "autocfg",
+ "defmt 0.3.101",
+ "heapless",
+ "serde",
+]
+
+[[package]]
+name = "ff"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0b50bfb653653f9ca9095b427bed08ab8d75a137839d9ad64eb11810d5b6393"
+dependencies = [
+ "rand_core 0.6.4",
+ "subtle",
+]
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "futures"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b147ee9d1f6d097cef9ce628cd2ee62288d963e16fb287bd9286455b241382d"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf29c38818342a3b26b5b923639e7b1f4a61fc5e76102d4b1981c6dc7a7579d"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-io"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"
+
+[[package]]
+name = "futures-macro"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893"
+
+[[package]]
+name = "futures-task"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"
+
+[[package]]
+name = "futures-util"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "slab",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+ "zeroize",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "wasi",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 5.3.0",
+ "wasip2",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "r-efi 6.0.0",
+ "rand_core 0.10.1",
+ "wasip2",
+ "wasip3",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "gimli"
+version = "0.32.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7"
+
+[[package]]
+name = "gloo-timers"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbb143cf96099802033e0d4f4963b19fd2e0b728bcf076cd9cf7f6634f092994"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "group"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
+dependencies = [
+ "ff",
+ "rand_core 0.6.4",
+ "subtle",
+]
+
+[[package]]
+name = "hash32"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47d60b12902ba28e2730cd37e95b8c9223af2808df9e902d4df49588d1470606"
+dependencies = [
+ "byteorder",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.15.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+dependencies = [
+ "foldhash",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+
+[[package]]
+name = "heapless"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad"
+dependencies = [
+ "hash32",
+ "stable_deref_trait",
+]
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
+name = "hex-conservative"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fda06d18ac606267c40c04e41b9947729bf8b9efe74bd4e82b61a5f26a510b9f"
+dependencies = [
+ "arrayvec",
+]
+
+[[package]]
+name = "hex-conservative"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "271e0d19bcb473b6675739a2b536076b24a082316cb5199ad918edce10c599e8"
+dependencies = [
+ "arrayvec",
+]
+
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest",
+]
+
+[[package]]
+name = "http"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a"
+dependencies = [
+ "bytes",
+ "itoa",
+]
+
+[[package]]
+name = "httparse"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
+
+[[package]]
+name = "icu_collections"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599"
+dependencies = [
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a"
+
+[[package]]
+name = "icu_properties"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "020bfc02fe870ec3a66d93e677ccca0562506e5872c650f893269e08615d74ec"
+dependencies = [
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "616c294cf8d725c6afcd8f55abc17c56464ef6211f9ed59cccffe534129c77af"
+
+[[package]]
+name = "icu_provider"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "id-arena"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
+
+[[package]]
+name = "idna"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6"
+dependencies = [
+ "unicode-bidi",
+ "unicode-normalization",
+]
+
+[[package]]
+name = "idna"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.16.1",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "inout"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
+dependencies = [
+ "block-padding",
+ "generic-array",
+]
+
+[[package]]
+name = "instant"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e0242819d153cba4b4b05a5a8f2a7e9bbf97b6055b2a002b395c96b5ff3c0222"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "io-uring"
+version = "0.7.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9080b15e63775b9a2ac7dca720f7050a8b955e092ea0f6020a4a80f69998cdc0"
+dependencies = [
+ "bitflags 2.11.0",
+ "cfg-if",
+ "libc",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[package]]
+name = "jiff-tzdb"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "142bd39932ad231f10513df9ab62661fead8719872150b7ad02a2df79f4e141e"
+
+[[package]]
+name = "js-sys"
+version = "0.3.91"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b49715b7073f385ba4bc528e5747d02e66cb39c6146efb66b781f131f0fb399c"
+dependencies = [
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "k256"
+version = "0.13.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6e3919bbaa2945715f0bb6d3934a173d1e9a59ac23767fbaaef277265a7411b"
+dependencies = [
+ "cfg-if",
+ "elliptic-curve",
+]
+
+[[package]]
+name = "leb128fmt"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
+
+[[package]]
+name = "libc"
+version = "0.2.183"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d"
+
+[[package]]
+name = "litemap"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
+
+[[package]]
+name = "log"
+version = "0.4.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
+
+[[package]]
+name = "lru"
+version = "0.18.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef9ac18847474e638e3702b76c65d4eb93428471a74778ef0f1be711717f89b5"
+
+[[package]]
+name = "mediatype"
+version = "0.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "120fa187be19d9962f0926633453784691731018a2bf936ddb4e29101b79c4a7"
+
+[[package]]
+name = "memchr"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
+
+[[package]]
+name = "miniz_oxide"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
+dependencies = [
+ "adler2",
+]
+
+[[package]]
+name = "mio"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a69bcab0ad47271a0234d9422b131806bf3968021e5dc9328caf2d4cd58557fc"
+dependencies = [
+ "libc",
+ "wasi",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "negentropy"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3d66662cb5ca384d4991509755ed5a42dd8e31c4282bf881938e506fc3146ec"
+
+[[package]]
+name = "nostr"
+version = "0.44.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7d3d987ea7078dc36947cde532637c472a229426702e4331dd7667325378bd9"
+dependencies = [
+ "aes",
+ "base64",
+ "bech32 0.11.1",
+ "bip39",
+ "bitcoin_hashes 0.14.1",
+ "cbc",
+ "chacha20",
+ "chacha20poly1305",
+ "getrandom 0.2.17",
+ "hex",
+ "instant",
+ "scrypt",
+ "secp256k1 0.29.1",
+ "serde",
+ "serde_json",
+ "unicode-normalization",
+ "url",
+ "url-fork",
+]
+
+[[package]]
+name = "nostr"
+version = "0.45.5"
+source = "git+https://github.com/nostrdevkit/nostr.git?rev=de3031aa99986eb29b3f34580355f9a099e4c927#de3031aa99986eb29b3f34580355f9a099e4c927"
+dependencies = [
+ "base64",
+ "bech32 0.12.0",
+ "bip39",
+ "bitcoin_hashes 1.2.0",
+ "cbc",
+ "chacha20",
+ "chacha20poly1305",
+ "faster-hex",
+ "opaquerr",
+ "rand 0.10.1",
+ "secp256k1 0.30.0",
+ "serde",
+ "serde_json",
+ "unicode-normalization",
+ "universal-time",
+ "url",
+ "zeroize",
+]
+
+[[package]]
+name = "nostr-database"
+version = "0.45.2"
+source = "git+https://github.com/nostrdevkit/nostr.git?rev=de3031aa99986eb29b3f34580355f9a099e4c927#de3031aa99986eb29b3f34580355f9a099e4c927"
+dependencies = [
+ "nostr 0.45.5",
+ "opaquerr",
+]
+
+[[package]]
+name = "nostr-gossip"
+version = "0.45.1"
+source = "git+https://github.com/nostrdevkit/nostr.git?rev=de3031aa99986eb29b3f34580355f9a099e4c927#de3031aa99986eb29b3f34580355f9a099e4c927"
+dependencies = [
+ "nostr 0.45.5",
+ "opaquerr",
+]
+
+[[package]]
+name = "nostr-sdk"
+version = "0.45.4"
+source = "git+https://github.com/nostrdevkit/nostr.git?rev=de3031aa99986eb29b3f34580355f9a099e4c927#de3031aa99986eb29b3f34580355f9a099e4c927"
+dependencies = [
+ "async-utility",
+ "async-wsocket",
+ "faster-hex",
+ "futures",
+ "lru",
+ "negentropy",
+ "nostr 0.45.5",
+ "nostr-database",
+ "nostr-gossip",
+ "opaquerr",
+ "rand 0.10.1",
+ "tokio",
+ "tokio-stream",
+ "tracing",
+ "universal-time",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "object"
+version = "0.37.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "opaque-debug"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
+
+[[package]]
+name = "opaquerr"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f933a4265d5cdad61d19bbdfc972ea5726d56cd8d3d57b8f2d3c365dd42bee9"
+
+[[package]]
+name = "password-hash"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "346f04948ba92c43e8469c1ee6736c7563d71012b17d40745260fe106aac2166"
+dependencies = [
+ "base64ct",
+ "rand_core 0.6.4",
+ "subtle",
+]
+
+[[package]]
+name = "pbkdf2"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2"
+dependencies = [
+ "digest",
+ "hmac",
+]
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
+
+[[package]]
+name = "poly1305"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8159bd90725d2df49889a078b54f4f79e87f1f8a8444194cdca81d38f5393abf"
+dependencies = [
+ "cpufeatures",
+ "opaque-debug",
+ "universal-hash",
+]
+
+[[package]]
+name = "potential_utf"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77"
+dependencies = [
+ "zerovec",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "prettyplease"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+
+[[package]]
+name = "radroots_blossom"
+version = "0.1.0-alpha"
+dependencies = [
+ "mediatype",
+ "serde",
+ "sha2",
+ "unicode-general-category",
+ "url",
+]
+
+[[package]]
+name = "radroots_core"
+version = "0.1.0-alpha"
+dependencies = [
+ "rust_decimal",
+ "serde",
+]
+
+[[package]]
+name = "radroots_event"
+version = "0.1.0-alpha"
+dependencies = [
+ "hex",
+ "jiff-tzdb",
+ "radroots_blossom",
+ "radroots_core",
+ "radroots_identity",
+ "radroots_protocol",
+ "serde",
+ "serde_json",
+ "sha2",
+ "unicode-general-category",
+ "url",
+]
+
+[[package]]
+name = "radroots_event_codec"
+version = "0.1.0-alpha"
+dependencies = [
+ "hex",
+ "radroots_blossom",
+ "radroots_core",
+ "radroots_event",
+ "radroots_identity",
+ "radroots_protocol",
+ "secp256k1 0.29.1",
+ "serde",
+ "serde_json",
+ "sha2",
+]
+
+[[package]]
+name = "radroots_identity"
+version = "0.1.0-alpha"
+dependencies = [
+ "k256",
+ "serde",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "radroots_nostr"
+version = "0.1.0-alpha"
+dependencies = [
+ "nostr 0.44.7",
+ "radroots_event",
+ "radroots_event_codec",
+ "radroots_identity",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.18",
+ "zeroize",
+]
+
+[[package]]
+name = "radroots_nostr_socket_browser_fixture"
+version = "0.0.0"
+dependencies = [
+ "async-utility",
+ "futures",
+ "js-sys",
+ "radroots_event_codec",
+ "radroots_transport",
+ "radroots_transport_nostr",
+ "radroots_transport_nostr_browser",
+ "serde_json",
+ "universal-time",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+]
+
+[[package]]
+name = "radroots_protocol"
+version = "0.1.0-alpha"
+dependencies = [
+ "radroots_identity",
+ "serde",
+ "sha2",
+ "zeroize",
+]
+
+[[package]]
+name = "radroots_transport"
+version = "0.1.0-alpha"
+dependencies = [
+ "radroots_event",
+ "radroots_identity",
+ "radroots_protocol",
+ "serde",
+ "sha2",
+]
+
+[[package]]
+name = "radroots_transport_nostr"
+version = "0.1.0-alpha"
+dependencies = [
+ "async-utility",
+ "async-wsocket",
+ "futures",
+ "getrandom 0.4.2",
+ "nostr-sdk",
+ "radroots_event_codec",
+ "radroots_nostr",
+ "radroots_protocol",
+ "radroots_transport",
+ "serde_json",
+ "sha2",
+ "tokio",
+ "url",
+ "wasm-bindgen-futures",
+ "web-time",
+]
+
+[[package]]
+name = "radroots_transport_nostr_browser"
+version = "0.1.0-alpha"
+dependencies = [
+ "async-utility",
+ "futures",
+ "js-sys",
+ "radroots_transport",
+ "radroots_transport_nostr",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+ "web-time",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+dependencies = [
+ "rand_chacha 0.9.0",
+ "rand_core 0.9.5",
+]
+
+[[package]]
+name = "rand"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2e8e8bcc7961af1fdac401278c6a831614941f6164ee3bf4ce61b7edb162207"
+dependencies = [
+ "getrandom 0.4.2",
+ "rand_core 0.10.1",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.5",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom 0.2.17",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
+dependencies = [
+ "getrandom 0.3.4",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
+
+[[package]]
+name = "ring"
+version = "0.17.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "getrandom 0.2.17",
+ "libc",
+ "untrusted",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "rust_decimal"
+version = "1.40.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61f703d19852dbf87cbc513643fa81428361eb6940f1ac14fd58155d295a3eb0"
+dependencies = [
+ "arrayvec",
+ "num-traits",
+ "serde",
+]
+
+[[package]]
+name = "rustc-demangle"
+version = "0.1.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b74b56ffa8bb2830709a538c2cbcae9aa062db0d2a42563bfb09bdaae44020eb"
+
+[[package]]
+name = "rustls"
+version = "0.23.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48e13bd8c0e9365c43cfa5c9e8f9ad49d3c8444926c9aac819e0e4dc503c8fdf"
+dependencies = [
+ "once_cell",
+ "ring",
+ "rustls-pki-types",
+ "rustls-webpki",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-pki-types"
+version = "1.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be040f8b0a225e40375822a563fa9524378b9d63112f53e19ffff34df5d33fdd"
+dependencies = [
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-webpki"
+version = "0.103.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2"
+dependencies = [
+ "ring",
+ "rustls-pki-types",
+ "untrusted",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "salsa20"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97a22f5af31f73a954c10289c93e8a50cc23d971e80ee446f1f6f7137a088213"
+dependencies = [
+ "cipher",
+]
+
+[[package]]
+name = "scrypt"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0516a385866c09368f0b5bcd1caff3366aace790fcd46e2bb032697bb172fd1f"
+dependencies = [
+ "password-hash",
+ "pbkdf2",
+ "salsa20",
+ "sha2",
+]
+
+[[package]]
+name = "sec1"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
+dependencies = [
+ "base16ct",
+ "der",
+ "generic-array",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "secp256k1"
+version = "0.29.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9465315bc9d4566e1724f0fffcbcc446268cb522e60f9a27bcded6b19c108113"
+dependencies = [
+ "rand 0.8.5",
+ "secp256k1-sys",
+ "serde",
+]
+
+[[package]]
+name = "secp256k1"
+version = "0.30.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b50c5943d326858130af85e049f2661ba3c78b26589b8ab98e65e80ae44a1252"
+dependencies = [
+ "bitcoin_hashes 0.14.1",
+ "rand 0.8.5",
+ "secp256k1-sys",
+]
+
+[[package]]
+name = "secp256k1-sys"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4387882333d3aa8cb20530a17c69a3752e97837832f34f6dccc760e715001d9"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "semver"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.149"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "sha1"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a978451301f4db1d02937a4ab3ccce137717b81826e79b7d49ffe3244a13c3b8"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "slab"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+
+[[package]]
+name = "socket2"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e"
+dependencies = [
+ "libc",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
+
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "3.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a207d6d6a2b7fc470b80443726053f18a2481b7e1eee970597051596567987a3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
+dependencies = [
+ "thiserror-impl 2.0.18",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "tinystr"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e61e67053d25a4e82c844e8424039d9745781b3fc4f32b8d55ed50f5f667ef3"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
+
+[[package]]
+name = "tokio"
+version = "1.47.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89e49afdadebb872d3145a5638b59eb0691ea23e46ca484037cfab3b76b95038"
+dependencies = [
+ "backtrace",
+ "bytes",
+ "io-uring",
+ "libc",
+ "mio",
+ "pin-project-lite",
+ "slab",
+ "socket2",
+ "tokio-macros",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "tokio-happy-eyeballs"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8564c32dfb6f4257f8bc6edfc178a34af97520e0b7b9815500c55eb3d092f29f"
+dependencies = [
+ "tokio",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e06d43f1345a3bcd39f6a56dbb7dcab2ba47e68e8ac134855e7e2bdbaf8cab8"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "tokio-rustls"
+version = "0.26.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61"
+dependencies = [
+ "rustls",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-socks"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7e2948f60dbe26b35f2c7fb74ac2854c1fddded0fe9d7548fcc674a246f7615"
+dependencies = [
+ "either",
+ "futures-util",
+ "thiserror 1.0.69",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-stream"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32da49809aab5c3bc678af03902d4ccddea2a87d028d86392a4b1560c6906c70"
+dependencies = [
+ "futures-core",
+ "pin-project-lite",
+ "tokio",
+ "tokio-util",
+]
+
+[[package]]
+name = "tokio-tungstenite"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d25a406cddcc431a75d3d9afc6a7c0f7428d4891dd973e4d54c56b46127bf857"
+dependencies = [
+ "futures-util",
+ "log",
+ "rustls",
+ "rustls-pki-types",
+ "tokio",
+ "tokio-rustls",
+ "tungstenite",
+ "webpki-roots 0.26.11",
+]
+
+[[package]]
+name = "tokio-util"
+version = "0.7.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "494815d09bf52b5548659851081238f0ca39ff638363907596da739561c62c52"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "tracing"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
+dependencies = [
+ "pin-project-lite",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "tungstenite"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8628dcc84e5a09eb3d8423d6cb682965dea9133204e8fb3efee74c2a0c259442"
+dependencies = [
+ "bytes",
+ "data-encoding",
+ "http",
+ "httparse",
+ "log",
+ "rand 0.9.2",
+ "rustls",
+ "rustls-pki-types",
+ "sha1",
+ "thiserror 2.0.18",
+ "utf-8",
+]
+
+[[package]]
+name = "typenum"
+version = "1.20.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
+
+[[package]]
+name = "unicode-bidi"
+version = "0.3.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c1cb5db39152898a79168971543b1cb5020dff7fe43c8dc468b0885f5e29df5"
+
+[[package]]
+name = "unicode-general-category"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b993bddc193ae5bd0d623b49ec06ac3e9312875fdae725a975c51db1cc1677f"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unicode-normalization"
+version = "0.1.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fd4f6878c9cb28d874b009da9e8d183b5abc80117c40bbd187a1fde336be6e8"
+dependencies = [
+ "tinyvec",
+]
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
+[[package]]
+name = "universal-hash"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea"
+dependencies = [
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "universal-time"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47a939edecc3c5a7b83c02e5f6b3c31d2bc69eabcc9a87ab12c6d37ee6dbc856"
+
+[[package]]
+name = "untrusted"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+
+[[package]]
+name = "url"
+version = "2.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
+dependencies = [
+ "form_urlencoded",
+ "idna 1.1.0",
+ "percent-encoding",
+ "serde",
+ "serde_derive",
+]
+
+[[package]]
+name = "url-fork"
+version = "3.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fa3323c39b8e786154d3000b70ae9af0e9bd746c9791456da0d4a1f68ad89d6"
+dependencies = [
+ "form_urlencoded",
+ "idna 0.5.0",
+ "percent-encoding",
+ "serde",
+]
+
+[[package]]
+name = "utf-8"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "wasip2"
+version = "1.0.2+wasi-0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasip3"
+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",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.114"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6532f9a5c1ece3798cb1c2cfdba640b9b3ba884f5db45973a6f442510a87d38e"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-futures"
+version = "0.4.64"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9c5522b3a28661442748e09d40924dfb9ca614b21c00d3fd135720e48b67db8"
+dependencies = [
+ "cfg-if",
+ "futures-util",
+ "js-sys",
+ "once_cell",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.114"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18a2d50fcf105fb33bb15f00e7a77b772945a2ee45dcf454961fd843e74c18e6"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.114"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03ce4caeaac547cdf713d280eda22a730824dd11e6b8c3ca9e42247b25c631e3"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.114"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75a326b8c223ee17883a4251907455a2431acc2791c98c26279376490c378c16"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "wasm-encoder"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319"
+dependencies = [
+ "leb128fmt",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasm-metadata"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909"
+dependencies = [
+ "anyhow",
+ "indexmap",
+ "wasm-encoder",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
+dependencies = [
+ "bitflags 2.11.0",
+ "hashbrown 0.15.5",
+ "indexmap",
+ "semver",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.91"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "854ba17bb104abfb26ba36da9729addc7ce7f06f5c0f90f3c391f8461cca21f9"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "web-time"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "webpki-roots"
+version = "0.26.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
+dependencies = [
+ "webpki-roots 1.0.6",
+]
+
+[[package]]
+name = "webpki-roots"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22cfaf3c063993ff62e73cb4311efde4db1efb31ab78a3e5c457939ad5cc0bed"
+dependencies = [
+ "rustls-pki-types",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+dependencies = [
+ "windows-targets 0.53.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm 0.52.6",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.53.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
+dependencies = [
+ "windows-link",
+ "windows_aarch64_gnullvm 0.53.1",
+ "windows_aarch64_msvc 0.53.1",
+ "windows_i686_gnu 0.53.1",
+ "windows_i686_gnullvm 0.53.1",
+ "windows_i686_msvc 0.53.1",
+ "windows_x86_64_gnu 0.53.1",
+ "windows_x86_64_gnullvm 0.53.1",
+ "windows_x86_64_msvc 0.53.1",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
+
+[[package]]
+name = "wit-bindgen"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
+dependencies = [
+ "wit-bindgen-rust-macro",
+]
+
+[[package]]
+name = "wit-bindgen-core"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc"
+dependencies = [
+ "anyhow",
+ "heck",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-bindgen-rust"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21"
+dependencies = [
+ "anyhow",
+ "heck",
+ "indexmap",
+ "prettyplease",
+ "syn 2.0.117",
+ "wasm-metadata",
+ "wit-bindgen-core",
+ "wit-component",
+]
+
+[[package]]
+name = "wit-bindgen-rust-macro"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a"
+dependencies = [
+ "anyhow",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "wit-bindgen-core",
+ "wit-bindgen-rust",
+]
+
+[[package]]
+name = "wit-component"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
+dependencies = [
+ "anyhow",
+ "bitflags 2.11.0",
+ "indexmap",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "wasm-encoder",
+ "wasm-metadata",
+ "wasmparser",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-parser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "indexmap",
+ "log",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser",
+]
+
+[[package]]
+name = "writeable"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9"
+
+[[package]]
+name = "yoke"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954"
+dependencies = [
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "synstructure",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "efbb2a062be311f2ba113ce66f697a4dc589f85e78a4aea276200804cea0ed87"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e8bc7269b54418e7aeeef514aa68f8690b8c0489a06b0136e5f57c4c5ccab89"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "synstructure",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13c156562582aa81c60cb29407084cdb54c4164760106ab78e6c5b0858cf64e"
+
+[[package]]
+name = "zerotrie"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "zmij"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
+
+[[patch.unused]]
+name = "radroots_geonames"
+version = "0.1.0-alpha"
+
+[[patch.unused]]
+name = "radroots_nostr_connect"
+version = "0.1.0-alpha"
+
+[[patch.unused]]
+name = "radroots_secrets"
+version = "0.1.0-alpha"
+
+[[patch.unused]]
+name = "radroots_signing"
+version = "0.1.0-alpha"
+
+[[patch.unused]]
+name = "radroots_storage"
+version = "0.1.0-alpha"
+
+[[patch.unused]]
+name = "radroots_storage_sqlite"
+version = "0.1.0-alpha"
+
+[[patch.unused]]
+name = "radroots_sync"
+version = "0.1.0-alpha"
+
+[[patch.unused]]
+name = "radroots_trade"
+version = "0.1.0-alpha"
diff --git a/crates/transport_nostr_browser/tests/browser/Cargo.toml b/crates/transport_nostr_browser/tests/browser/Cargo.toml
@@ -0,0 +1,24 @@
+[package]
+name = "radroots_nostr_socket_browser_fixture"
+version = "0.0.0"
+publish = false
+edition = "2024"
+rust-version = "1.99.0"
+
+[workspace]
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+radroots_transport_nostr_browser = { path = "../.." }
+radroots_transport_nostr = { path = "../../../transport_nostr" }
+radroots_transport = { path = "../../../transport", features = ["std"] }
+radroots_event_codec = { path = "../../../event_codec", default-features = false, features = ["json"] }
+serde_json = "=1.0.149"
+futures = "=0.3.32"
+async-utility = { git = "https://github.com/yukibtc/async-utility", rev = "b323ae0c1c1424b78bf8bb8832b95e86771f1dee", version = "=0.3.2" }
+js-sys = "=0.3.91"
+wasm-bindgen = "=0.2.114"
+wasm-bindgen-futures = "=0.4.64"
+universal-time = "=0.3.1"
diff --git a/crates/transport_nostr_browser/tests/browser/run.mjs b/crates/transport_nostr_browser/tests/browser/run.mjs
@@ -0,0 +1,158 @@
+import assert from 'node:assert/strict';
+import {createRequire} from 'node:module';
+import {createServer} from 'node:http';
+import {readFile} from 'node:fs/promises';
+import {resolve} from 'node:path';
+
+const [tools, packageDir, engine = 'chromium'] = process.argv.slice(2);
+assert(tools && packageDir && ['chromium', 'firefox', 'webkit'].includes(engine));
+const require = createRequire(resolve(tools, 'package.json'));
+const playwright = require('playwright');
+// Use the already locked browser harness's server implementation; no new
+// product dependency, relay implementation or protocol client is introduced.
+const {wsServer: WebSocketServer} = require(resolve(tools, 'node_modules/playwright-core/lib/utilsBundle.js'));
+const wss = new WebSocketServer({noServer: true});
+const sockets = new Set();
+const upgrades = [];
+const observed = [];
+process.on('uncaughtExceptionMonitor',()=>console.error(JSON.stringify({engine,upgrades,observed})));
+const vectors = JSON.parse(await readFile('contracts/conformance/vectors/event/verified_admission.v1.json','utf8'));
+const event = vectors.vectors[1].input.event;
+
+const observer = `
+const ActualWebSocket=globalThis.WebSocket, observedSockets=[];
+const actualTimeout=globalThis.setTimeout,actualClear=globalThis.clearTimeout,activeTimers=new Set();
+globalThis.setTimeout=(callback,delay,...args)=>{
+ let id;id=actualTimeout.call(globalThis,(...values)=>{activeTimers.delete(id);callback(...values);},delay,...args);activeTimers.add(id);return id;
+};
+globalThis.clearTimeout=id=>{activeTimers.delete(id);return actualClear.call(globalThis,id);};
+globalThis.WebSocket=class extends ActualWebSocket {
+ constructor(...args){super(...args);observedSockets.push(this);}
+};
+globalThis.waitForBrowserSocketClose=async route=>{
+ const socket=observedSockets.findLast(socket=>socket.url.endsWith('/'+route));
+ if(!socket)throw Error('missing actual socket: '+route);
+ const deadline=performance.now()+5000;
+ while(socket.readyState!==ActualWebSocket.CLOSED){
+ if(performance.now()>=deadline)throw Error('socket did not close: '+route);
+ await new Promise(resolve=>setTimeout(resolve,10));
+ }
+};
+globalThis.forceBrowserSocketBackpressure=()=>{
+ Object.defineProperty(observedSockets.at(-1),'bufferedAmount',{get(){return 4*1024*1024;}});
+};
+async function verifyCleanup(checkTimers=true){
+ await new Promise(resolve=>setTimeout(resolve,80));
+ for(const socket of observedSockets){
+ if(socket.onopen||socket.onmessage||socket.onerror||socket.onclose)throw Error('retained socket callback');
+ if(socket.readyState!==ActualWebSocket.CLOSED)throw Error('retained open socket: '+socket.url+' state='+socket.readyState);
+ }
+ const inert=['unpolled','cancelled-owner','revoked-owner','expired-owner'];
+ if(observedSockets.some(socket=>inert.some(route=>socket.url.endsWith('/'+route))))throw Error('inert or expired connection performed I/O');
+ if(observedSockets.filter(socket=>socket.url.endsWith('/stall')).length!==2)throw Error('missing original pending handshake attempts');
+ if(checkTimers && activeTimers.size)throw Error('retained browser socket timer: '+activeTimers.size);
+ return observedSockets.length;
+}`;
+const execute = `
+const {default:init,verify_socket,verify_shared_session,fixture_event}=await import('./fixture.js');await init();
+const passed=Array.from(await verify_socket(base));const directDisposed=await verifyCleanup();
+const shared=Array.from(await verify_shared_session(base));const disposed=await verifyCleanup(false);
+return {passed,shared,directDisposed,disposed,expectedRaw:fixture_event()};`;
+const worker = `${observer}
+self.onmessage=async event=>{try{const base=event.data;const run=async()=>{${execute}};self.postMessage(await run());}
+catch(error){self.postMessage({error:String(error)});}};`;
+const server = createServer(async (req, res) => {
+ try {
+ if(req.url==='/'){res.setHeader('content-type','text/html');res.end('<!doctype html><title>Browser socket fixture</title>');return;}
+ if(req.url==='/worker.js'){res.setHeader('content-type','text/javascript');res.end(worker);return;}
+ const name = new Map([['/fixture.js','fixture.js'],['/fixture_bg.wasm','fixture_bg.wasm']]).get(req.url);
+ if(!name){res.statusCode=404;res.end();return;}
+ res.setHeader('content-type',name.endsWith('.wasm')?'application/wasm':'text/javascript');
+ res.end(await readFile(resolve(packageDir,name)));
+ } catch {res.statusCode=500;res.end();}
+});
+server.on('connection',socket=>{sockets.add(socket);socket.on('close',()=>sockets.delete(socket));});
+server.on('upgrade',(req,socket,head)=>{
+ upgrades.push(req.url);
+ if(req.url==='/stall')return; // Original pending HTTP upgrade, closed by its owner.
+ wss.handleUpgrade(req,socket,head,ws=>{
+ ws.on('error',()=>{});
+ if(req.url==='/echo')ws.on('message',(data,binary)=>{observed.push({route:req.url,binary,bytes:data.length});ws.send(data,{binary});});
+ else if(req.url==='/oversize')ws.send('a'.repeat(1025));
+ else if(req.url==='/unicode')ws.send('é'.repeat(800));
+ else if(req.url==='/binary-large')ws.send(Buffer.alloc(1025));
+ else if(req.url==='/items')for(let i=0;i<257;i++)ws.send('');
+ else if(req.url==='/bytes')for(let i=0;i<9;i++)ws.send(Buffer.alloc(512*1024));
+ else if(req.url==='/disconnect'){ws.send('before close');ws.close(1000,'peer done');}
+ else if(req.url.startsWith('/shared-'))ws.on('message',(data,binary)=>{
+ if(binary)return;
+ const wire=data.toString(),message=JSON.parse(wire);
+ observed.push({route:req.url,wire});
+ if(message[0]==='REQ'){
+ if(req.url==='/shared-disconnect'){ws.close(1000,'history interrupted');return;}
+ if(req.url==='/shared-observer')return;
+ ws.send(JSON.stringify(['EVENT',message[1],event]));
+ ws.send(JSON.stringify(['EOSE',message[1]]));
+ }else if(message[0]==='EVENT'){
+ if(req.url==='/shared-noack')return;
+ if(req.url==='/shared-badack'){ws.send(JSON.stringify(['OK',message[1].id+'00',true,'']));return;}
+ ws.send(JSON.stringify(['OK','11'.repeat(32),true,'unrelated']));
+ ws.send(JSON.stringify(['OK',message[1].id,req.url!=='/shared-negative','']));
+ }
+ });
+ });
+});
+await new Promise(resolve=>server.listen(0,'127.0.0.1',resolve));
+const base=`ws://127.0.0.1:${server.address().port}`;
+let browser;
+const deadline=setTimeout(()=>{void browser?.close();},120000);deadline.unref();
+try {
+ // The locked Juggler driver asserts when worker WebSocket-open events lack
+ // its page request record. Use its supported BiDi channel with the exact same
+ // cached Firefox executable; retain every real worker/product assertion.
+ const automation=engine==='firefox'?'webdriver_bidi':'playwright_default';
+ const options=engine==='firefox'?{headless:true,channel:'moz-firefox-nightly',executablePath:playwright.firefox.executablePath()}:{headless:true};
+ browser=await playwright[engine].launch(options);
+ const page=await browser.newPage();
+ const errors=[],expectedUserAgentDiagnostics=[];
+ const expectedDiagnostics=new Set([
+ `Firefox can’t establish a connection to the server at ${base}/stall.`,
+ `The connection to ${base}/stall was interrupted while the page was loading.`,
+ ]);
+ page.on('pageerror',error=>{
+ // BiDi reports these user-agent diagnostics as script errors for the two
+ // deliberately interrupted handshakes. Retain the exact messages separately;
+ // every other error still fails, including exceptions from product code.
+ if(engine==='firefox' && automation==='webdriver_bidi' && expectedDiagnostics.has(error.message))expectedUserAgentDiagnostics.push(error.message);
+ else errors.push(error.message);
+ });
+ await page.goto(`http://127.0.0.1:${server.address().port}/`);
+ await page.addScriptTag({content:observer});
+ const main=await page.evaluate(new Function('base',`return (async()=>{${execute}})();`),base);
+ console.error(JSON.stringify({phase:'main_completed',engine,result:main}));
+ const dedicated=await page.evaluate(base=>new Promise((resolve,reject)=>{
+ const worker=new Worker('./worker.js',{type:'module'});
+ worker.onerror=event=>{worker.terminate();reject(Error(event.message));};
+ worker.onmessage=event=>{worker.terminate();event.data.error?reject(Error(event.data.error)):resolve(event.data);};
+ worker.postMessage(base);
+ }),base);
+ assert.equal(main.passed.length,19);
+ assert.equal(main.shared.length,7);
+ assert.deepEqual(main,dedicated);
+ assert.deepEqual(errors,[]);
+ assert(!upgrades.includes('/unpolled'));
+ const publications=observed.filter(item=>item.wire?.startsWith('["EVENT",'));
+ assert.equal(publications.length,8);
+ for(const publication of publications)assert.equal(publication.wire,`["EVENT",${main.expectedRaw}]`);
+ // A deadline may expire before the user agent transmits an HTTP upgrade.
+ assert(upgrades.filter(path=>path==='/stall').length<=4);
+ assert(expectedUserAgentDiagnostics.length<=8);
+ console.log(JSON.stringify({engine,automation,version:browser.version(),main,dedicated,pageErrors:errors,expectedUserAgentDiagnostics,upgrades,observed}));
+} finally {
+ clearTimeout(deadline);
+ await browser?.close();
+ for(const client of wss.clients)client.terminate();
+ for(const socket of sockets)socket.destroy();
+ await new Promise(resolve=>wss.close(resolve));
+ await new Promise(resolve=>server.close(resolve));
+}
diff --git a/crates/transport_nostr_browser/tests/browser/src/clock.rs b/crates/transport_nostr_browser/tests/browser/src/clock.rs
@@ -0,0 +1,26 @@
+//! The pinned SDK requires exactly one clock selection in the final WASM
+//! artifact. This fixture is an artifact root, not a provider library. Use real
+//! browser clocks in both pages and workers; never substitute a test timestamp.
+
+use std::time::Duration;
+use universal_time::{Instant, MonotonicClock, SystemTime, WallClock};
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+ #[wasm_bindgen(js_namespace = performance, js_name = now)]
+ fn monotonic_ms() -> f64;
+}
+
+struct BrowserClock;
+impl WallClock for BrowserClock {
+ fn system_time(&self) -> SystemTime {
+ SystemTime::from_unix_duration(Duration::from_secs_f64(js_sys::Date::now() / 1_000.0))
+ }
+}
+impl MonotonicClock for BrowserClock {
+ fn instant(&self) -> Instant {
+ Instant::from_ticks(Duration::from_secs_f64(monotonic_ms() / 1_000.0))
+ }
+}
+universal_time::define_time_provider!(BrowserClock);
diff --git a/crates/transport_nostr_browser/tests/browser/src/lib.rs b/crates/transport_nostr_browser/tests/browser/src/lib.rs
@@ -0,0 +1,328 @@
+#![forbid(unsafe_code)]
+
+mod clock;
+mod shared;
+
+use futures::{FutureExt, task::AtomicWaker};
+use radroots_transport::host::websocket::{Admission, Connector, Error, Frame, Socket};
+use radroots_transport_nostr_browser::BrowserConnector;
+use std::{
+ net::IpAddr,
+ num::NonZeroUsize,
+ sync::{
+ Arc,
+ atomic::{AtomicBool, AtomicUsize, Ordering},
+ },
+ task::Context,
+ time::Duration,
+};
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+ #[wasm_bindgen(js_namespace = globalThis, js_name = waitForBrowserSocketClose)]
+ fn wait_for_close(route: &str) -> js_sys::Promise;
+ #[wasm_bindgen(js_namespace = globalThis, js_name = forceBrowserSocketBackpressure)]
+ fn force_backpressure();
+}
+
+struct Grant {
+ live: AtomicBool,
+ charge: AtomicBool,
+ bytes: AtomicUsize,
+ frames: AtomicUsize,
+ reader: AtomicWaker,
+ writer: AtomicWaker,
+}
+impl Grant {
+ fn new() -> Arc<Self> {
+ Arc::new(Self {
+ live: AtomicBool::new(true),
+ charge: AtomicBool::new(true),
+ bytes: AtomicUsize::new(0),
+ frames: AtomicUsize::new(0),
+ reader: AtomicWaker::new(),
+ writer: AtomicWaker::new(),
+ })
+ }
+ fn revoke(&self) {
+ self.live.store(false, Ordering::SeqCst);
+ self.reader.wake();
+ self.writer.wake();
+ }
+}
+impl Admission for Grant {
+ fn permits_address(&self, _: IpAddr) -> bool {
+ self.live.load(Ordering::SeqCst)
+ }
+ fn admitted_read(&self, context: &Context<'_>) -> bool {
+ self.reader.register(context.waker());
+ self.live.load(Ordering::SeqCst)
+ }
+ fn admitted_write(&self, context: &Context<'_>) -> bool {
+ self.writer.register(context.waker());
+ self.live.load(Ordering::SeqCst)
+ }
+ fn charge(&self, bytes: usize, frames: usize, data: usize) -> bool {
+ assert_eq!(frames, data);
+ self.bytes.fetch_add(bytes, Ordering::SeqCst);
+ self.frames.fetch_add(frames, Ordering::SeqCst);
+ self.charge.load(Ordering::SeqCst) && self.live.load(Ordering::SeqCst)
+ }
+}
+fn check(value: bool, name: &str) -> Result<(), JsValue> {
+ if value {
+ Ok(())
+ } else {
+ Err(JsValue::from_str(name))
+ }
+}
+fn error(value: Error) -> JsValue {
+ JsValue::from_str(&value.to_string())
+}
+async fn pause() {
+ async_utility::time::sleep(Duration::from_millis(40)).await;
+}
+async fn connect(
+ base: &str,
+ route: &str,
+ limit: usize,
+ grant: Arc<Grant>,
+) -> Result<Arc<dyn Socket>, JsValue> {
+ BrowserConnector
+ .connect(
+ &format!("{base}/{route}"),
+ Duration::from_secs(2),
+ NonZeroUsize::new(limit).unwrap(),
+ grant,
+ )
+ .await
+ .map_err(error)
+}
+
+#[wasm_bindgen]
+pub async fn verify_socket(base: String) -> Result<js_sys::Array, JsValue> {
+ let passed = js_sys::Array::new();
+ let grant = Grant::new();
+ let endpoint = format!("{base}/unpolled");
+ let future = BrowserConnector.connect(
+ &endpoint,
+ Duration::from_secs(1),
+ NonZeroUsize::new(1024).unwrap(),
+ grant.clone(),
+ );
+ drop(future);
+ pause().await;
+ passed.push(&"unpolled inert".into());
+
+ let endpoint = format!("{base}/cancelled-owner");
+ let mut attempt = BrowserConnector.connect(
+ &endpoint,
+ Duration::from_secs(1),
+ NonZeroUsize::new(1).unwrap(),
+ Grant::new(),
+ );
+ check(
+ attempt.as_mut().now_or_never().is_none(),
+ "owner initially scheduled",
+ )?;
+ drop(attempt);
+ pause().await;
+ passed.push(&"cancellation before owner startup".into());
+
+ let endpoint = format!("{base}/revoked-owner");
+ let revoked_grant = Grant::new();
+ let mut attempt = BrowserConnector.connect(
+ &endpoint,
+ Duration::from_secs(1),
+ NonZeroUsize::new(1).unwrap(),
+ revoked_grant.clone(),
+ );
+ check(
+ attempt.as_mut().now_or_never().is_none(),
+ "revocable owner initially scheduled",
+ )?;
+ revoked_grant.revoke();
+ check(
+ matches!(attempt.await, Err(Error::Policy)),
+ "owner rechecks original grant",
+ )?;
+ passed.push(&"revocation before owner startup".into());
+
+ let endpoint = format!("{base}/expired-owner");
+ let mut attempt = BrowserConnector.connect(
+ &endpoint,
+ Duration::from_millis(5),
+ NonZeroUsize::new(1).unwrap(),
+ Grant::new(),
+ );
+ check(
+ attempt.as_mut().now_or_never().is_none(),
+ "deadline owner initially scheduled",
+ )?;
+ let until = js_sys::Date::now() + 25.0;
+ while js_sys::Date::now() < until {}
+ check(
+ matches!(attempt.await, Err(Error::Timeout)),
+ "delayed owner cannot renew original deadline",
+ )?;
+ passed.push(&"original deadline before owner startup".into());
+
+ let socket = connect(&base, "echo", 1024, grant.clone()).await?;
+ let text = Frame::Text(" [\"original\", 7, \"café🌱\"] \n".into());
+ socket.send(text.clone()).await.map_err(error)?;
+ check(
+ socket.receive().await.map_err(error)? == Some(text),
+ "original text",
+ )?;
+ let binary = Frame::Binary(vec![0, 255, 10, 13, 128]);
+ socket.send(binary.clone()).await.map_err(error)?;
+ check(
+ socket.receive().await.map_err(error)? == Some(binary),
+ "original binary",
+ )?;
+ check(
+ grant.frames.load(Ordering::SeqCst) == 2 && grant.bytes.load(Ordering::SeqCst) > 5,
+ "original admission charges",
+ )?;
+ passed.push(&"original text binary and admission".into());
+ for frame in [Frame::Ping(vec![]), Frame::Pong(vec![]), Frame::Close(None)] {
+ check(
+ socket.send(frame).await == Err(Error::Unsupported),
+ "unsupported control",
+ )?;
+ }
+ check(
+ !BrowserConnector.supports_ping(),
+ "browser ping unavailable",
+ )?;
+ check(
+ socket.send(Frame::Binary(vec![0; 1025])).await == Err(Error::Protocol),
+ "outgoing size",
+ )?;
+ passed.push(&"control and outgoing bounds".into());
+
+ let mut pending = socket.send(Frame::Text("observer lost".into()));
+ check(
+ pending.as_mut().now_or_never().is_none(),
+ "admitted send starts pending",
+ )?;
+ drop(pending);
+ check(
+ socket.send(Frame::Text("cannot replace".into())).await == Err(Error::Policy),
+ "cancelled observer cannot replace accepted send",
+ )?;
+ check(
+ socket.receive().await.map_err(error)? == Some(Frame::Text("observer lost".into())),
+ "original admitted send retained",
+ )?;
+ passed.push(&"send observer cancellation".into());
+
+ let mut pending = socket.receive();
+ check(pending.as_mut().now_or_never().is_none(), "pending receive")?;
+ let revoking = grant.clone();
+ wasm_bindgen_futures::spawn_local(async move {
+ async_utility::time::sleep(Duration::from_millis(10)).await;
+ revoking.revoke();
+ });
+ check(
+ pending.await == Err(Error::Policy),
+ "revocation wakes original reader",
+ )?;
+ check(
+ socket.send(Frame::Text("denied".into())).await.is_err(),
+ "revoked send",
+ )?;
+ socket.close().await.map_err(error)?;
+ socket.close().await.map_err(error)?;
+ drop(socket);
+ passed.push(&"revocation and repeated cleanup".into());
+
+ for (route, limit, expected) in [
+ ("oversize", 1024, Error::Protocol),
+ ("unicode", 1024, Error::Protocol),
+ ("binary-large", 1024, Error::Protocol),
+ ("items", 1024, Error::Policy),
+ ("bytes", 512 * 1024, Error::Policy),
+ ] {
+ let socket = connect(&base, route, limit, Grant::new()).await?;
+ wasm_bindgen_futures::JsFuture::from(wait_for_close(route)).await?;
+ check(socket.receive().await == Err(expected), route)?;
+ socket.close().await.map_err(error)?;
+ passed.push(&JsValue::from_str(route));
+ }
+ let grant = Grant::new();
+ grant.charge.store(false, Ordering::SeqCst);
+ let socket = connect(&base, "echo", 1024, grant.clone()).await?;
+ socket
+ .send(Frame::Text("original refusal".into()))
+ .await
+ .map_err(error)?;
+ check(
+ socket.receive().await == Err(Error::Policy),
+ "original budget refuses callback",
+ )?;
+ check(
+ grant.bytes.load(Ordering::SeqCst) == 16,
+ "refused original bytes charged",
+ )?;
+ socket.close().await.map_err(error)?;
+ passed.push(&"original budget refusal".into());
+
+ let socket = connect(&base, "echo", 1024, Grant::new()).await?;
+ force_backpressure();
+ check(
+ socket.send(Frame::Text("must not enqueue".into())).await == Err(Error::Policy),
+ "reported browser outbound credit",
+ )?;
+ socket.close().await.map_err(error)?;
+ passed.push(&"reported outbound buffer refusal".into());
+
+ let socket = connect(&base, "disconnect", 1024, Grant::new()).await?;
+ check(
+ socket.receive().await.map_err(error)? == Some(Frame::Text("before close".into())),
+ "retained before peer close",
+ )?;
+ check(
+ socket.receive().await.map_err(error)?.is_none(),
+ "peer end observed",
+ )?;
+ socket.close().await.map_err(error)?;
+ passed.push(&"peer disconnect preserves preceding message".into());
+
+ let socket = connect(&base, "echo", 1024, Grant::new()).await?;
+ drop(socket);
+ pause().await;
+ passed.push(&"last socket observer cleanup".into());
+
+ let endpoint = format!("{base}/stall");
+ let mut attempt = BrowserConnector.connect(
+ &endpoint,
+ Duration::from_secs(2),
+ NonZeroUsize::new(1).unwrap(),
+ Grant::new(),
+ );
+ check(
+ attempt.as_mut().now_or_never().is_none(),
+ "connect initially pending",
+ )?;
+ pause().await;
+ drop(attempt);
+ pause().await;
+ passed.push(&"cancelled handshake cleanup".into());
+ let result = BrowserConnector
+ .connect(
+ &endpoint,
+ Duration::from_millis(20),
+ NonZeroUsize::new(1).unwrap(),
+ Grant::new(),
+ )
+ .await;
+ check(
+ matches!(result, Err(Error::Timeout)),
+ "original handshake deadline",
+ )?;
+ passed.push(&"handshake deadline cleanup".into());
+ pause().await;
+ Ok(passed)
+}
diff --git a/crates/transport_nostr_browser/tests/browser/src/shared.rs b/crates/transport_nostr_browser/tests/browser/src/shared.rs
@@ -0,0 +1,176 @@
+use crate::{check, pause};
+use futures::FutureExt;
+use radroots_transport::{
+ DeliveryRequest, EventSink, EventSource, FetchRequest, TargetSet,
+ outcome::FetchTargetState,
+ policy::{SatisfactionClass, SatisfactionPolicy, TargetPolicy},
+ sink::DeliveryPayload,
+ source::FetchBounds,
+};
+use radroots_transport_nostr::{
+ Config, RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind, RelayUrlPolicy,
+};
+use wasm_bindgen::prelude::*;
+
+fn now() -> u64 {
+ js_sys::Date::now() as u64
+}
+fn profile_config(base: &str, route: &str) -> Config {
+ Config::from_profile(
+ RelayProfile::explicit(
+ RelayProfileKind::Simulator,
+ [RelayEndpoint::new(
+ format!("{base}/{route}"),
+ RelayUrlPolicy::Local,
+ RelayAccess::ReadWrite,
+ )
+ .unwrap()],
+ )
+ .unwrap(),
+ )
+ .with_timeouts(1000, 500, 100)
+ .unwrap()
+}
+fn targets(config: &Config) -> TargetSet {
+ TargetSet::new(
+ config
+ .relays()
+ .iter()
+ .map(|relay| relay.to_target().unwrap())
+ .collect(),
+ )
+ .unwrap()
+}
+
+#[wasm_bindgen]
+pub fn fixture_event() -> String {
+ // Consume the source-owned conformance vector, retaining an independently
+ // verified signature while deliberately changing only its outer whitespace.
+ let vectors: serde_json::Value = serde_json::from_str(include_str!(
+ "../../../../../contracts/conformance/vectors/event/verified_admission.v1.json"
+ ))
+ .unwrap();
+ format!(
+ " \n{} \t",
+ serde_json::to_string_pretty(&vectors["vectors"][1]["input"]["event"]).unwrap()
+ )
+}
+
+#[wasm_bindgen]
+pub async fn verify_shared_session(base: String) -> Result<js_sys::Array, JsValue> {
+ let passed = js_sys::Array::new();
+ let raw = fixture_event();
+ let config = profile_config(&base, "shared-accept");
+ let transport = radroots_transport_nostr_browser::create_transport(config.clone());
+ let page = transport
+ .fetch(
+ FetchRequest::new(
+ "browser-source",
+ targets(&config),
+ FetchBounds::new(10, now() + 5000).unwrap(),
+ )
+ .unwrap(),
+ )
+ .await
+ .map_err(|_| JsValue::from_str("shared fetch error"))?;
+ check(
+ page.events().len() == 1 && page.target_outcomes()[0].state() == FetchTargetState::Complete,
+ "shared verified source and EOSE",
+ )?;
+ passed.push(&"shared independently verified event and EOSE".into());
+ let request = DeliveryRequest::new(
+ "browser-exact",
+ DeliveryPayload::new(radroots_event_codec::decode::signed_event(&raw).unwrap()),
+ targets(&config),
+ SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()),
+ now() + 5000,
+ )
+ .unwrap();
+ let receipt = transport
+ .deliver(request)
+ .await
+ .map_err(|_| JsValue::from_str("shared deliver error"))?;
+ check(
+ receipt.target_receipts()[0]
+ .outcome()
+ .satisfies(SatisfactionClass::Accepted),
+ "shared exact acceptance",
+ )?;
+ transport.shutdown().await;
+ check(transport.admission_is_closed(), "shared shutdown admission")?;
+ passed.push(&"shared original publication and matching ACK".into());
+
+ for route in ["shared-negative", "shared-noack", "shared-badack"] {
+ let config = profile_config(&base, route);
+ let transport = radroots_transport_nostr_browser::create_transport(config.clone());
+ let request = DeliveryRequest::new(
+ route,
+ DeliveryPayload::new(radroots_event_codec::decode::signed_event(&raw).unwrap()),
+ targets(&config),
+ SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()),
+ now() + 5000,
+ )
+ .unwrap();
+ let receipt = transport
+ .deliver(request)
+ .await
+ .map_err(|_| JsValue::from_str("shared negative deliver error"))?;
+ check(
+ !receipt.target_receipts()[0]
+ .outcome()
+ .satisfies(SatisfactionClass::Accepted),
+ route,
+ )?;
+ transport.shutdown().await;
+ passed.push(&JsValue::from_str(route));
+ }
+
+ let config = profile_config(&base, "shared-disconnect");
+ let transport = radroots_transport_nostr_browser::create_transport(config.clone());
+ let page = transport
+ .fetch(
+ FetchRequest::new(
+ "browser-gap",
+ targets(&config),
+ FetchBounds::new(10, now() + 5000).unwrap(),
+ )
+ .unwrap(),
+ )
+ .await
+ .map_err(|_| JsValue::from_str("shared disconnect fetch error"))?;
+ check(
+ page.target_outcomes()[0].state() != FetchTargetState::Complete,
+ "disconnect cannot prove complete history",
+ )?;
+ transport.shutdown().await;
+ passed.push(&"shared disconnect never proves complete history".into());
+
+ let config = profile_config(&base, "shared-observer");
+ let transport = radroots_transport_nostr_browser::create_transport(config.clone());
+ let mut fetch = transport.fetch(
+ FetchRequest::new(
+ "browser-observer",
+ targets(&config),
+ FetchBounds::new(10, now() + 5000).unwrap(),
+ )
+ .unwrap(),
+ );
+ check(
+ fetch.as_mut().now_or_never().is_none(),
+ "shared fetch starts pending",
+ )?;
+ pause().await;
+ check(
+ fetch.as_mut().now_or_never().is_none(),
+ "shared original observer remains pending",
+ )?;
+ drop(fetch);
+ transport.shutdown().await;
+ pause().await;
+ check(
+ !transport.has_in_flight_operations(),
+ "shared observer loss frees original call",
+ )?;
+ passed.push(&"shared fetch observer loss and shutdown".into());
+ Ok(passed)
+}