lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

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:
Mcrates/transport_nostr_browser/README.md | 12++++++++++++
Mcrates/transport_nostr_browser/src/browser.rs | 6+++++-
Mcrates/transport_nostr_browser/src/connector.rs | 65++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-----
Mcrates/transport_nostr_browser/src/lib.rs | 7++++++-
Acrates/transport_nostr_browser/src/scope.rs | 181+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/transport_nostr_browser/src/state.rs | 3+++
Mcrates/transport_nostr_browser/tests/browser/run.mjs | 34+++++++++++++++++++++++-----------
Mcrates/transport_nostr_browser/tests/browser/src/lib.rs | 110+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--------
Mcrates/transport_nostr_browser/tests/browser/src/shared.rs | 6+++++-
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(