commit dab69b04c05705240b44e61c75111e8647977be9
parent 6638d84dc7017108e218196e8e3f4234b901885e
Author: triesap <tyson@radroots.org>
Date: Tue, 20 Oct 2026 05:59:01 +0000
transport: Own bounded browser socket disposal scopes
- Permanently close original socket admission and resume cancelled disposal
- Keep scope completion independent of concurrent per-socket observers
- Verify original-owner cleanup, clone closure and sibling isolation
- Preserve native coverage gates and execute every browser page and worker case
Diffstat:
9 files changed, 394 insertions(+), 30 deletions(-)
diff --git a/crates/transport_nostr_browser/README.md b/crates/transport_nostr_browser/README.md
@@ -33,3 +33,15 @@ 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.
+The user agent may retain an underlying pending network task after DOM close;
+repeated interrupted handshakes can consume its per-origin connection capacity.
+Subsequent calls still consume their original deadlines and cannot infer remote
+cleanup from local disposal.
+
+Cloned `BrowserConnector` handles own one disposal scope, with at most 64 retained
+original socket owners. Keep the connector when composing a client. After
+stopping the shared protocol session, await its `close` method before closing
+storage: it permanently refuses new owners and waits for every original local
+socket owner to detach callbacks and initiate close. A cancelled close resumes
+the same disposal. Separate connector scopes remain independent. This scope
+does not manage protocol membership, grant retries or join upstream SDK tasks.
diff --git a/crates/transport_nostr_browser/src/browser.rs b/crates/transport_nostr_browser/src/browser.rs
@@ -15,6 +15,7 @@ pub(crate) async fn connect(
timeout: Duration,
limit: NonZeroUsize,
admission: Arc<dyn Admission>,
+ scope: &crate::scope::Scope,
) -> Result<Arc<dyn Socket>, Error> {
poll_fn(|context| {
Poll::Ready(
@@ -27,6 +28,7 @@ pub(crate) async fn connect(
})
.await?;
let shared = Arc::new(Shared::new(admission, limit.get()));
+ scope.register(&shared)?;
let (sender, receiver) = oneshot::channel();
let mut cancellation = CancelConnect(Some(shared.clone()));
start_owner(
@@ -200,7 +202,9 @@ impl Socket for BrowserSocket {
self.shared.stop();
poll_fn(|context| {
self.shared.closer.register(context.waker());
- if self.shared.lock()?.finished {
+ let finished = self.shared.lock()?.finished;
+ if finished {
+ self.shared.closer.take();
Poll::Ready(Ok(()))
} else {
Poll::Pending
diff --git a/crates/transport_nostr_browser/src/connector.rs b/crates/transport_nostr_browser/src/connector.rs
@@ -2,8 +2,36 @@ use radroots_transport::host::websocket::{Admission, Connector, Error, IoFuture,
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;
+#[derive(Clone, Default)]
+pub struct BrowserConnector {
+ #[cfg(any(target_arch = "wasm32", test))]
+ scope: Arc<crate::scope::Scope>,
+}
+
+impl std::fmt::Debug for BrowserConnector {
+ fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ formatter.write_str("BrowserConnector([owned])")
+ }
+}
+
+impl BrowserConnector {
+ /// Permanently refuses new socket owners and waits for local callback
+ /// disposal on every original socket in this scope. Does not join upstream
+ /// SDK tasks or prove a remote close handshake. Resume after cancellation.
+ /// An unpolled future has no effect. Clones share this same close boundary.
+ pub fn close(&self) -> IoFuture<'_, Result<(), Error>> {
+ Box::pin(async move {
+ #[cfg(any(target_arch = "wasm32", test))]
+ {
+ self.scope.close().await
+ }
+ #[cfg(not(any(target_arch = "wasm32", test)))]
+ {
+ Ok(())
+ }
+ })
+ }
+}
impl Connector for BrowserConnector {
fn supports_ping(&self) -> bool {
@@ -24,7 +52,14 @@ impl Connector for BrowserConnector {
}
#[cfg(target_arch = "wasm32")]
{
- crate::browser::connect(endpoint, timeout, max_message_bytes, admission).await
+ crate::browser::connect(
+ endpoint,
+ timeout,
+ max_message_bytes,
+ admission,
+ &self.scope,
+ )
+ .await
}
#[cfg(not(target_arch = "wasm32"))]
{
@@ -90,13 +125,14 @@ mod tests {
}
#[test]
fn non_browser_connection_refuses_and_zero_deadline_does_not_start_io() {
- assert!(!BrowserConnector.supports_ping());
+ let connector = BrowserConnector::default();
+ assert!(!connector.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(
+ let result = futures::executor::block_on(connector.connect(
endpoint,
duration,
NonZeroUsize::new(1).unwrap(),
@@ -120,4 +156,23 @@ mod tests {
let profile = RelayProfile::explicit(RelayProfileKind::Public, [endpoint]).unwrap();
let _transport = crate::create_transport(Config::from_profile(profile));
}
+
+ #[test]
+ fn clones_share_disposal_and_diagnostics_never_expose_buffered_peer_data() {
+ use crate::state::{Shared, Status};
+ let connector = BrowserConnector::default();
+ let socket = Arc::new(Shared::new(Grant::new(true), 64));
+ socket.lock().unwrap().status = Status::Open;
+ socket
+ .push(radroots_transport::host::websocket::Frame::Text(
+ "private buffered peer content".into(),
+ ))
+ .unwrap();
+ connector.scope.register(&socket).unwrap();
+ assert!(!format!("{connector:?}").contains("private buffered peer content"));
+ let clone = connector.clone();
+ socket.finish();
+ futures::executor::block_on(clone.close()).unwrap();
+ assert_eq!(connector.scope.register(&socket), Err(Error::Closed));
+ }
}
diff --git a/crates/transport_nostr_browser/src/lib.rs b/crates/transport_nostr_browser/src/lib.rs
@@ -6,6 +6,8 @@
mod browser;
mod connector;
#[cfg(any(target_arch = "wasm32", test))]
+mod scope;
+#[cfg(any(target_arch = "wasm32", test))]
mod state;
pub use connector::BrowserConnector;
@@ -15,5 +17,8 @@ pub use connector::BrowserConnector;
pub fn create_transport(
config: radroots_transport_nostr::Config,
) -> radroots_transport_nostr::NostrTransport {
- radroots_transport_nostr::NostrTransport::new(config, std::sync::Arc::new(BrowserConnector))
+ radroots_transport_nostr::NostrTransport::new(
+ config,
+ std::sync::Arc::new(BrowserConnector::default()),
+ )
}
diff --git a/crates/transport_nostr_browser/src/scope.rs b/crates/transport_nostr_browser/src/scope.rs
@@ -0,0 +1,181 @@
+//! Local disposal inventory only; the common session owns protocol membership.
+
+use crate::state::Shared;
+use futures::{future::poll_fn, lock::Mutex as AsyncMutex};
+use radroots_transport::host::websocket::Error;
+use std::{
+ sync::{Arc, Mutex, Weak},
+ task::Poll,
+};
+
+const MAX_SOCKET_OWNERS: usize = 64;
+
+#[derive(Default)]
+struct State {
+ closed: bool,
+ owners: Vec<Weak<Shared>>,
+}
+
+#[derive(Default)]
+pub(crate) struct Scope {
+ state: Mutex<State>,
+ closing: AsyncMutex<()>,
+}
+
+impl Scope {
+ pub(crate) fn register(&self, owner: &Arc<Shared>) -> Result<(), Error> {
+ let mut state = self.state.lock().map_err(|_| Error::Closed)?;
+ if state.closed {
+ return Err(Error::Closed);
+ }
+ // Weak entries confer no lifetime or effect authority. Do not drop a
+ // last strong owner or call foreign callbacks while holding this lock.
+ state.owners.retain(|owner| owner.strong_count() != 0);
+ if state.owners.len() == MAX_SOCKET_OWNERS {
+ return Err(Error::Policy);
+ }
+ state.owners.push(Arc::downgrade(owner));
+ Ok(())
+ }
+
+ pub(crate) async fn close(&self) -> Result<(), Error> {
+ let _closing = self.closing.lock().await;
+ let owners: Vec<_> = {
+ let mut state = self.state.lock().map_err(|_| Error::Closed)?;
+ state.closed = true;
+ state.owners.iter().filter_map(Weak::upgrade).collect()
+ };
+ for owner in &owners {
+ owner.stop();
+ }
+ for owner in &owners {
+ poll_fn(|context| {
+ owner.scope_closer.register(context.waker());
+ let finished = owner.lock()?.finished;
+ if finished {
+ owner.scope_closer.take();
+ Poll::Ready(Ok(()))
+ } else {
+ Poll::Pending
+ }
+ })
+ .await?;
+ }
+ self.state.lock().map_err(|_| Error::Closed)?.owners.clear();
+ Ok(())
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::state::tests::AdmissionCounter;
+ use futures::{
+ FutureExt,
+ task::{ArcWake, waker},
+ };
+ use std::{
+ future::Future,
+ sync::atomic::{AtomicUsize, Ordering},
+ task::Context,
+ };
+ fn owner() -> Arc<Shared> {
+ Arc::new(Shared::new(AdmissionCounter::new(true), 8))
+ }
+
+ #[test]
+ fn empty_and_unpolled_close_are_inert_until_observed_and_then_permanent() {
+ let scope = Scope::default();
+ drop(scope.close());
+ let socket = owner();
+ scope.register(&socket).unwrap();
+ socket.finish();
+ futures::executor::block_on(scope.close()).unwrap();
+ futures::executor::block_on(scope.close()).unwrap();
+ assert_eq!(scope.register(&owner()), Err(Error::Closed));
+ futures::executor::block_on(Scope::default().close()).unwrap();
+ }
+
+ #[test]
+ fn registration_is_bounded_and_dropped_owners_release_inventory_credit() {
+ let scope = Scope::default();
+ let mut held = Vec::new();
+ for _ in 0..MAX_SOCKET_OWNERS {
+ let socket = owner();
+ scope.register(&socket).unwrap();
+ held.push(socket);
+ }
+ let extra = owner();
+ assert_eq!(scope.register(&extra), Err(Error::Policy));
+ held.pop();
+ scope.register(&extra).unwrap();
+ assert_eq!(scope.state.lock().unwrap().owners.len(), MAX_SOCKET_OWNERS);
+ }
+
+ #[test]
+ fn cancelled_close_retains_all_original_owners_and_does_not_affect_a_sibling() {
+ let scope = Scope::default();
+ let sibling = Scope::default();
+ let a = owner();
+ let b = owner();
+ let other = owner();
+ scope.register(&a).unwrap();
+ scope.register(&b).unwrap();
+ sibling.register(&other).unwrap();
+ let mut close = Box::pin(scope.close());
+ assert!(close.as_mut().now_or_never().is_none());
+ assert!(a.lock().unwrap().stopping && b.lock().unwrap().stopping);
+ assert!(!other.lock().unwrap().stopping);
+ assert_eq!(scope.register(&owner()), Err(Error::Closed));
+ drop(close);
+ a.finish();
+ let mut retry = Box::pin(scope.close());
+ assert!(retry.as_mut().now_or_never().is_none());
+ b.finish();
+ futures::executor::block_on(retry).unwrap();
+ assert!(!other.lock().unwrap().stopping);
+ }
+
+ #[test]
+ fn socket_and_scope_close_observers_have_independent_completion_wakes() {
+ struct Count(AtomicUsize);
+ impl ArcWake for Count {
+ fn wake_by_ref(this: &Arc<Self>) {
+ this.0.fetch_add(1, Ordering::SeqCst);
+ }
+ }
+ let scope = Scope::default();
+ let socket = owner();
+ scope.register(&socket).unwrap();
+ let scope_count = Arc::new(Count(AtomicUsize::new(0)));
+ let socket_count = Arc::new(Count(AtomicUsize::new(0)));
+ let scope_waker = waker(scope_count.clone());
+ let socket_waker = waker(socket_count.clone());
+ let mut close = Box::pin(scope.close());
+ assert!(
+ close
+ .as_mut()
+ .poll(&mut Context::from_waker(&scope_waker))
+ .is_pending()
+ );
+ socket.closer.register(&socket_waker);
+ socket.finish();
+ assert!(scope_count.0.load(Ordering::SeqCst) > 0);
+ assert!(socket_count.0.load(Ordering::SeqCst) > 0);
+ futures::executor::block_on(close).unwrap();
+ }
+
+ #[test]
+ fn poisoned_inventory_never_claims_disposal_or_admits_another_owner() {
+ let scope = Scope::default();
+ let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+ let _guard = scope.state.lock().unwrap();
+ panic!("intentional scope poison");
+ }));
+ assert_eq!(scope.register(&owner()), Err(Error::Closed));
+ assert_eq!(
+ futures::executor::block_on(scope.close()),
+ Err(Error::Closed)
+ );
+ }
+}
diff --git a/crates/transport_nostr_browser/src/state.rs b/crates/transport_nostr_browser/src/state.rs
@@ -55,6 +55,7 @@ pub(crate) struct Shared {
pub(crate) actor: AtomicWaker,
pub(crate) reader: AtomicWaker,
pub(crate) closer: AtomicWaker,
+ pub(crate) scope_closer: AtomicWaker,
}
impl Shared {
@@ -73,6 +74,7 @@ impl Shared {
actor: AtomicWaker::new(),
reader: AtomicWaker::new(),
closer: AtomicWaker::new(),
+ scope_closer: AtomicWaker::new(),
}
}
@@ -84,6 +86,7 @@ impl Shared {
self.actor.wake();
self.reader.wake();
self.closer.wake();
+ self.scope_closer.wake();
}
pub(crate) fn stop(&self) {
diff --git a/crates/transport_nostr_browser/tests/browser/run.mjs b/crates/transport_nostr_browser/tests/browser/run.mjs
@@ -41,23 +41,24 @@ globalThis.waitForBrowserSocketClose=async route=>{
globalThis.forceBrowserSocketBackpressure=()=>{
Object.defineProperty(observedSockets.at(-1),'bufferedAmount',{get(){return 4*1024*1024;}});
};
-async function verifyCleanup(checkTimers=true){
+async function verifyCleanup(checkTimers=true,expectedStalls=2){
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'];
+ const inert=['unpolled','cancelled-owner','revoked-owner','expired-owner','closed-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(observedSockets.filter(socket=>socket.url.endsWith('/stall')).length!==expectedStalls)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 {default:init,verify_socket,verify_scope,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 scope=Array.from(await verify_scope(base));const scopeDisposed=await verifyCleanup(true,3);
+const shared=Array.from(await verify_shared_session(base));const disposed=await verifyCleanup(false,3);
+return {passed,scope,shared,directDisposed,scopeDisposed,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)});}};`;
@@ -113,23 +114,33 @@ try {
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();
+ let 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=>{
+ const onPageError=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);
- });
+ };
+ page.on('pageerror',onPageError);
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}));
+ // Each context first proves disposal on its original objects. WebKit can
+ // retain the network tasks for cancelled HTTP upgrades after DOM close; six
+ // such deliberately stalled tasks otherwise block the next connection.
+ // Isolate page and worker fixture resources without renewing any deadline or
+ // claiming that local disposal proves a remote/network-task close handshake.
+ await page.close();
+ page=await browser.newPage();
+ page.on('pageerror',onPageError);
+ await page.goto(`http://127.0.0.1:${server.address().port}/`);
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));};
@@ -138,6 +149,7 @@ try {
}),base);
assert.equal(main.passed.length,19);
assert.equal(main.shared.length,7);
+ assert.equal(main.scope.length,4);
assert.deepEqual(main,dedicated);
assert.deepEqual(errors,[]);
assert(!upgrades.includes('/unpolled'));
@@ -145,8 +157,8 @@ try {
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);
+ assert(upgrades.filter(path=>path==='/stall').length<=6);
+ assert(expectedUserAgentDiagnostics.length<=12);
console.log(JSON.stringify({engine,automation,version:browser.version(),main,dedicated,pageErrors:errors,expectedUserAgentDiagnostics,upgrades,observed}));
} finally {
clearTimeout(deadline);
diff --git a/crates/transport_nostr_browser/tests/browser/src/lib.rs b/crates/transport_nostr_browser/tests/browser/src/lib.rs
@@ -89,7 +89,7 @@ async fn connect(
limit: usize,
grant: Arc<Grant>,
) -> Result<Arc<dyn Socket>, JsValue> {
- BrowserConnector
+ BrowserConnector::default()
.connect(
&format!("{base}/{route}"),
Duration::from_secs(2),
@@ -103,9 +103,10 @@ async fn connect(
#[wasm_bindgen]
pub async fn verify_socket(base: String) -> Result<js_sys::Array, JsValue> {
let passed = js_sys::Array::new();
+ let connector = BrowserConnector::default();
let grant = Grant::new();
let endpoint = format!("{base}/unpolled");
- let future = BrowserConnector.connect(
+ let future = connector.connect(
&endpoint,
Duration::from_secs(1),
NonZeroUsize::new(1024).unwrap(),
@@ -116,7 +117,7 @@ pub async fn verify_socket(base: String) -> Result<js_sys::Array, JsValue> {
passed.push(&"unpolled inert".into());
let endpoint = format!("{base}/cancelled-owner");
- let mut attempt = BrowserConnector.connect(
+ let mut attempt = connector.connect(
&endpoint,
Duration::from_secs(1),
NonZeroUsize::new(1).unwrap(),
@@ -132,7 +133,7 @@ pub async fn verify_socket(base: String) -> Result<js_sys::Array, JsValue> {
let endpoint = format!("{base}/revoked-owner");
let revoked_grant = Grant::new();
- let mut attempt = BrowserConnector.connect(
+ let mut attempt = connector.connect(
&endpoint,
Duration::from_secs(1),
NonZeroUsize::new(1).unwrap(),
@@ -150,7 +151,7 @@ pub async fn verify_socket(base: String) -> Result<js_sys::Array, JsValue> {
passed.push(&"revocation before owner startup".into());
let endpoint = format!("{base}/expired-owner");
- let mut attempt = BrowserConnector.connect(
+ let mut attempt = connector.connect(
&endpoint,
Duration::from_millis(5),
NonZeroUsize::new(1).unwrap(),
@@ -192,10 +193,7 @@ pub async fn verify_socket(base: String) -> Result<js_sys::Array, JsValue> {
"unsupported control",
)?;
}
- check(
- !BrowserConnector.supports_ping(),
- "browser ping unavailable",
- )?;
+ check(!connector.supports_ping(), "browser ping unavailable")?;
check(
socket.send(Frame::Binary(vec![0; 1025])).await == Err(Error::Protocol),
"outgoing size",
@@ -296,7 +294,7 @@ pub async fn verify_socket(base: String) -> Result<js_sys::Array, JsValue> {
passed.push(&"last socket observer cleanup".into());
let endpoint = format!("{base}/stall");
- let mut attempt = BrowserConnector.connect(
+ let mut attempt = connector.connect(
&endpoint,
Duration::from_secs(2),
NonZeroUsize::new(1).unwrap(),
@@ -310,7 +308,7 @@ pub async fn verify_socket(base: String) -> Result<js_sys::Array, JsValue> {
drop(attempt);
pause().await;
passed.push(&"cancelled handshake cleanup".into());
- let result = BrowserConnector
+ let result = connector
.connect(
&endpoint,
Duration::from_millis(20),
@@ -326,3 +324,93 @@ pub async fn verify_socket(base: String) -> Result<js_sys::Array, JsValue> {
pause().await;
Ok(passed)
}
+
+#[wasm_bindgen]
+pub async fn verify_scope(base: String) -> Result<js_sys::Array, JsValue> {
+ let passed = js_sys::Array::new();
+ let connector = BrowserConnector::default();
+ let sibling = BrowserConnector::default();
+ let endpoint = format!("{base}/echo");
+ let limit = NonZeroUsize::new(1024).unwrap();
+ let a = connector
+ .connect(&endpoint, Duration::from_secs(2), limit, Grant::new())
+ .await
+ .map_err(error)?;
+ let b = connector
+ .connect(&endpoint, Duration::from_secs(2), limit, Grant::new())
+ .await
+ .map_err(error)?;
+ let other = sibling
+ .connect(&endpoint, Duration::from_secs(2), limit, Grant::new())
+ .await
+ .map_err(error)?;
+ let (socket_done, scope_done) = futures::join!(a.close(), connector.close());
+ socket_done.map_err(error)?;
+ scope_done.map_err(error)?;
+ check(
+ b.receive().await.map_err(error)?.is_none(),
+ "all original scope sockets disposed",
+ )?;
+ check(
+ b.send(Frame::Text("closed".into())).await == Err(Error::Closed),
+ "scope cannot send after disposal",
+ )?;
+ let denied = connector
+ .connect(&endpoint, Duration::from_secs(2), limit, Grant::new())
+ .await;
+ check(
+ matches!(denied, Err(Error::Closed)),
+ "closed scope cannot admit another original owner",
+ )?;
+ passed.push(&"concurrent socket and scope disposal".into());
+ other
+ .send(Frame::Text("isolated scope".into()))
+ .await
+ .map_err(error)?;
+ check(
+ other.receive().await.map_err(error)? == Some(Frame::Text("isolated scope".into())),
+ "sibling scope remains live",
+ )?;
+ let copy = sibling.clone();
+ let (first, second) = futures::join!(sibling.close(), copy.close());
+ first.map_err(error)?;
+ second.map_err(error)?;
+ passed.push(&"scope isolation and shared clone closure".into());
+
+ let connector = BrowserConnector::default();
+ let stalled = format!("{base}/stall");
+ let mut attempt = connector.connect(&stalled, Duration::from_secs(2), limit, Grant::new());
+ check(
+ attempt.as_mut().now_or_never().is_none(),
+ "original pending scope handshake",
+ )?;
+ pause().await;
+ let mut closing = connector.close();
+ check(
+ closing.as_mut().now_or_never().is_none(),
+ "scope close starts pending before original owner disposal",
+ )?;
+ drop(closing);
+ check(
+ matches!(attempt.await, Err(Error::Closed)),
+ "original handshake refused by scope close",
+ )?;
+ connector.close().await.map_err(error)?;
+ passed.push(&"cancelled scope close resumes original disposal".into());
+
+ let connector = BrowserConnector::default();
+ let inert = format!("{base}/closed-owner");
+ let mut attempt = connector.connect(&inert, Duration::from_secs(2), limit, Grant::new());
+ check(
+ attempt.as_mut().now_or_never().is_none(),
+ "deferred original scope owner",
+ )?;
+ let (attempt, closed) = futures::join!(attempt, connector.close());
+ check(
+ matches!(attempt, Err(Error::Closed)),
+ "scope refuses before DOM owner starts",
+ )?;
+ closed.map_err(error)?;
+ passed.push(&"scope close before DOM owner startup".into());
+ Ok(passed)
+}
diff --git a/crates/transport_nostr_browser/tests/browser/src/shared.rs b/crates/transport_nostr_browser/tests/browser/src/shared.rs
@@ -75,7 +75,11 @@ pub async fn verify_shared_session(base: String) -> Result<js_sys::Array, JsValu
.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",
+ &format!(
+ "shared verified source and EOSE: events={} targets={:?}",
+ page.events().len(),
+ page.target_outcomes()
+ ),
)?;
passed.push(&"shared independently verified event and EOSE".into());
let request = DeliveryRequest::new(