Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
fix(workers): isolate source imports from evaluation graph traversal
ldm04dd6d641d4c1
diff --git a/moli-renderer-v8/src/worker/module_runtime.rs b/moli-renderer-v8/src/worker/module_runtime.rsindex a6e807973..c75aeb919 100644--- a/moli-renderer-v8/src/worker/module_runtime.rs+++ b/moli-renderer-v8/src/worker/module_runtime.rs@@ -959,6 +959,7 @@ impl WorkerDynamicModuleResolver {fn take_joined_root_imports(&mut self,key: &WorkerModuleKey,+ phase: Option<ModuleImportPhase>,) -> Vec<WorkerDynamicModuleImportJob> {let mut joined = Vec::new();let mut remaining = VecDeque::with_capacity(self.pending_imports.len());@@ -967,7 +968,8 @@ impl WorkerDynamicModuleResolver {&job.state,WorkerDynamicModuleImportJobState::JoinedRoot { key: joined_key }if joined_key == key- ) {+ ) && phase.is_none_or(|phase| job.phase == phase)+ {joined.push(job);} else {remaining.push_back(job);@@ -1051,12 +1053,25 @@ fn advance_worker_dynamic_module_import(let module_url = resolve_worker_module_specifier(&job.specifier, &job.base_url)?;let module_key = worker_module_key_for_attributes(&module_url, &job.attributes).map_err(|message| format!("{message} for dynamic import `{}`", job.specifier))?;- job.root_key = Some(module_key.clone());+ if job.phase == ModuleImportPhase::Source && module_key.kind != WorkerModuleKind::WebAssembly {+ return Err(WorkerDynamicModuleImportError::syntax_error(format!(+ "source-phase dynamic import `{}` does not resolve to a WebAssembly module",+ job.specifier+ )));+ }if let Some(error) = graph.borrow().source_fetch_failure(&module_key) {return Err(WorkerDynamicModuleImportError::type_error(format!("Failed to dynamically import module worker dependency `{module_url}`: {error}")));}+ let existing_root_entry = graph.borrow().entry_for_key(&module_key);+ if job.phase == ModuleImportPhase::Source && existing_root_entry.is_some() {+ // A compiled source is available even while another job is loading or+ // evaluating its dependencies. This job does not own that root's waiters.+ job.resolved_entry = existing_root_entry;+ return Ok(WorkerDynamicModuleImportAdvance::Complete);+ }+ job.root_key = Some(module_key.clone());if context.get_slot::<RefCell<WorkerDynamicModuleResolver>>().is_some_and(|dynamic_imports| dynamic_imports.borrow().root_import_in_flight(&module_key))@@ -1064,14 +1079,7 @@ fn advance_worker_dynamic_module_import(job.state = WorkerDynamicModuleImportJobState::JoinedRoot { key: module_key };return Ok(WorkerDynamicModuleImportAdvance::WaitingFetches);}- if job.phase == ModuleImportPhase::Source && module_key.kind != WorkerModuleKind::WebAssembly {- return Err(WorkerDynamicModuleImportError::syntax_error(format!(- "source-phase dynamic import `{}` does not resolve to a WebAssembly module",- job.specifier- )));- }let inherited_referrer_policy = graph.borrow().referrer_policy_for_url(&job.base_url);- let existing_root_entry = graph.borrow().entry_for_key(&module_key);let root_entry = match existing_root_entry {Some(entry) => entry,None => match load_worker_static_module_dependency(module_url)? {@@ -1110,18 +1118,19 @@ fn advance_worker_dynamic_module_import(},};job.resolved_entry = Some(root_entry);+ if job.phase == ModuleImportPhase::Source {+ return Ok(WorkerDynamicModuleImportAdvance::Complete);+ }match continue_worker_module_graph(scope,&graph,+ root_entry,&job.fetch_initiator_url,WorkerModuleGraphFetchCspSource::DynamicImportGraph,job.browser_request_metadata(),).map_err(|error| error.0.summary)?{- WorkerModuleGraphBuild::Ready if job.phase == ModuleImportPhase::Source => {- Ok(WorkerDynamicModuleImportAdvance::Complete)- }WorkerModuleGraphBuild::Ready => {finish_worker_dynamic_module_import_evaluation(scope, root_entry)}@@ -1181,6 +1190,18 @@ fn job_finish_fetch();} else {job.resolved_entry = Some(target_entry);+ // Source imports only share the root fetch, not dependency loading or+ // evaluation. Wake them before either of those steps can wait or fail.+ if let Some(imports) = context.get_slot::<RefCell<WorkerDynamicModuleResolver>>() {+ let mut imports = imports.borrow_mut();+ let sources =+ imports.take_joined_root_imports(&request.key, Some(ModuleImportPhase::Source));+ for mut source in sources {+ source.root_key = None;+ source.state = WorkerDynamicModuleImportJobState::Graph;+ imports.pending_imports.push_back(source);+ }+ }}Ok(())}@@ -1201,9 +1222,13 @@ fn job_resume_fetch_with_pending_keys(let root_entry = job.resolved_entry.ok_or_else(|| "dynamic import root module is not compiled".to_owned())?;+ if job.phase == ModuleImportPhase::Source {+ return Ok(WorkerDynamicModuleImportAdvance::Complete);+ }match continue_worker_module_graph_with_pending_keys(scope,&graph,+ root_entry,&request.initiator_url,request.csp_source(),request.graph_browser_request_metadata(),@@ -1211,12 +1236,6 @@ fn job_resume_fetch_with_pending_keys().map_err(|error| error.0.summary)?{- WorkerModuleGraphBuild::Ready if job.phase == ModuleImportPhase::Source => {- if has_pending_requests {- return Ok(WorkerDynamicModuleImportAdvance::WaitingFetches);- }- Ok(WorkerDynamicModuleImportAdvance::Complete)- }WorkerModuleGraphBuild::Ready => {if has_pending_requests {return Ok(WorkerDynamicModuleImportAdvance::WaitingFetches);@@ -1320,10 +1339,23 @@ fn resolve_worker_dynamic_module_import(job: WorkerDynamicModuleImportJob,) {let resolved_entry = job.resolved_entry;+ let phase = job.phase;let joined_imports = take_worker_dynamic_module_imports_joined_to_root(scope, &job);resolve_single_worker_dynamic_module_import(scope, job);for mut joined_job in joined_imports {joined_job.resolved_entry = resolved_entry;+ if phase == ModuleImportPhase::Source && joined_job.phase == ModuleImportPhase::Evaluation {+ // Sharing a source fetch does not link or evaluate the module. Resume+ // evaluation jobs from the cached root instead of reading its namespace.+ let context = v8::Local::new(scope, &joined_job.context);+ let imports = context+ .get_slot::<RefCell<WorkerDynamicModuleResolver>>()+ .expect("dynamic import resolver should be installed");+ joined_job.root_key = None;+ joined_job.state = WorkerDynamicModuleImportJobState::Graph;+ imports.borrow_mut().pending_imports.push_back(joined_job);+ continue;+ }resolve_single_worker_dynamic_module_import(scope, joined_job);}}@@ -1404,7 +1436,7 @@ fn take_worker_dynamic_module_imports_joined_to_root(};dynamic_imports.borrow_mut()- .take_joined_root_imports(root_key)+ .take_joined_root_imports(root_key, None)}fn reject_worker_dynamic_module_import(@@ -1497,6 +1529,7 @@ impl WorkerModuleBootstrapJob {match continue_worker_module_graph(scope,&self.runtime.graph,+ root_entry,&self.static_import_initiator_url,WorkerModuleGraphFetchCspSource::StaticModuleGraph,BrowserRequestMetadata::Fetch,@@ -1573,6 +1606,7 @@ impl WorkerModuleBootstrapJob {match continue_worker_module_graph_with_pending_keys(scope,&self.runtime.graph,+ root_entry,&self.static_import_initiator_url,WorkerModuleGraphFetchCspSource::StaticModuleGraph,BrowserRequestMetadata::Fetch,@@ -1961,23 +1995,23 @@ impl WorkerModuleGraph {});}- fn len(&self) -> usize {- self.records.len()- }-fn url(&self, entry: usize) -> &Url {&self.records[entry].source_url}- fn has_dependency(+ fn dependency_entry(&self,entry: usize,specifier: &str,attributes: &ModuleAttributesKey,- ) -> bool {- self.records[entry].dependencies.iter().any(|dependency| {- dependency.specifier == specifier && dependency.attributes == *attributes- })+ ) -> Option<usize> {+ self.records[entry]+ .dependencies+ .iter()+ .find(|dependency| {+ dependency.specifier == specifier && dependency.attributes == *attributes+ })+ .map(|dependency| dependency.target_entry)}fn module_url_for(&self, module: v8::Local<'_, v8::Module>) -> Option<Url> {@@ -2037,13 +2071,7 @@ impl WorkerModuleGraph {attributes: &ModuleAttributesKey,) -> Option<usize> {let referrer_entry = self.entry_for_module(referrer)?;- let dependency = self.records[referrer_entry]- .dependencies- .iter()- .find(|dependency| {- dependency.specifier == specifier && dependency.attributes == *attributes- })?;- Some(dependency.target_entry)+ self.dependency_entry(referrer_entry, specifier, attributes)}fn resolve_static_dependency_record(@@ -2116,6 +2144,7 @@ fn ensure_worker_module_entry(fn continue_worker_module_graph(scope: &mut v8::PinScope<'_, '_>,graph: &Rc<RefCell<WorkerModuleGraph>>,+ root_entry: usize,fetch_initiator_url: &Url,csp_source: WorkerModuleGraphFetchCspSource,browser_request_metadata: BrowserRequestMetadata,@@ -2123,6 +2152,7 @@ fn continue_worker_module_graph(continue_worker_module_graph_with_pending_keys(scope,graph,+ root_entry,fetch_initiator_url,csp_source,browser_request_metadata,@@ -2133,41 +2163,55 @@ fn continue_worker_module_graph(fn continue_worker_module_graph_with_pending_keys(scope: &mut v8::PinScope<'_, '_>,graph: &Rc<RefCell<WorkerModuleGraph>>,+ root_entry: usize,fetch_initiator_url: &Url,csp_source: WorkerModuleGraphFetchCspSource,browser_request_metadata: BrowserRequestMetadata,mut pending_keys: HashSet<WorkerModuleKey>,) -> WorkerModuleBootstrapResult<WorkerModuleGraphBuild> {- let mut entry = 0;+ // The module map also contains source-only and unrelated dynamic imports.+ // Expand only evaluation edges reachable from this job's root.+ let mut pending_entries = vec![root_entry];+ let mut visited = HashSet::new();let mut pending_requests = Vec::new();- while entry < graph.borrow().len() {+ while let Some(entry) = pending_entries.pop() {+ if !visited.insert(entry) {+ continue;+ }let url = graph.borrow().url(entry).clone();let requests = graph.borrow().requests(entry);for request in requests {if graph.borrow()- .has_dependency(entry, &request.specifier, &request.attributes)+ .dependency_entry(entry, &request.specifier, &request.attributes)+ .is_none(){- continue;- }- match resolve_worker_module_dependency(- scope,- graph,- entry,- &url,- fetch_initiator_url,- csp_source,- browser_request_metadata,- request,- &mut pending_keys,- )? {- WorkerModuleGraphBuild::Ready => {}- WorkerModuleGraphBuild::NeedFetches(requests) => {- pending_requests.extend(requests.requests);+ match resolve_worker_module_dependency(+ scope,+ graph,+ entry,+ &url,+ fetch_initiator_url,+ csp_source,+ browser_request_metadata,+ &request,+ &mut pending_keys,+ )? {+ WorkerModuleGraphBuild::Ready => {}+ WorkerModuleGraphBuild::NeedFetches(requests) => {+ pending_requests.extend(requests.requests);+ }}}+ if request.phase == ModuleImportPhase::Evaluation+ && let Some(dependency) =+ graph+ .borrow()+ .dependency_entry(entry, &request.specifier, &request.attributes)+ {+ pending_entries.push(dependency);+ }}- entry += 1;}if !pending_requests.is_empty() {return Ok(WorkerModuleGraphBuild::NeedFetches(@@ -2185,7 +2229,7 @@ fn resolve_worker_module_dependency(fetch_initiator_url: &Url,csp_source: WorkerModuleGraphFetchCspSource,browser_request_metadata: BrowserRequestMetadata,- request: WorkerModuleRequest,+ request: &WorkerModuleRequest,pending_keys: &mut HashSet<WorkerModuleKey>,) -> WorkerModuleBootstrapResult<WorkerModuleGraphBuild> {let dependency_url =@@ -2255,8 +2299,8 @@ fn resolve_worker_module_dependency(if let Some(target_entry) = existing_entry {graph.borrow_mut().add_dependency(entry,- request.specifier,- request.attributes,+ request.specifier.clone(),+ request.attributes.clone(),target_entry,);return Ok(WorkerModuleGraphBuild::Ready);@@ -2273,8 +2317,8 @@ fn resolve_worker_module_dependency(fetch_initiator_url.clone(),csp_source,Some(entry),- request.specifier,- request.attributes,+ request.specifier.clone(),+ request.attributes.clone(),graph.borrow().credentials_mode(),referrer_policy,browser_request_metadata,@@ -2291,9 +2335,12 @@ fn resolve_worker_module_dependency(dependency_key.url.clone(),referrer_policy,)?;- graph- .borrow_mut()- .add_dependency(entry, request.specifier, request.attributes, target_entry);+ graph.borrow_mut().add_dependency(+ entry,+ request.specifier.clone(),+ request.attributes.clone(),+ target_entry,+ );Ok(WorkerModuleGraphBuild::Ready)}diff --git a/moli-renderer-v8/src/worker/thread/tests/modules.rs b/moli-renderer-v8/src/worker/thread/tests/modules.rsindex a18274d9b..8376899dc 100644--- a/moli-renderer-v8/src/worker/thread/tests/modules.rs+++ b/moli-renderer-v8/src/worker/thread/tests/modules.rs@@ -5,6 +5,8 @@ use crate::worker::handle::WorkerParentErrorEventKind;use crate::worker::{WorkerErrorPhase, WorkerScriptResourceKind};use moli_crypto::sha256_hex;+mod source_phase;+const WORKER_WASM_IMPORT_PM: &[u8] = &[0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x08, 0x02, 0x60, 0x01, 0x7f, 0x00, 0x60,0x00, 0x00, 0x02, 0x19, 0x01, 0x12, 0x2e, 0x2f, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x2d, 0x68,@@ -2488,24 +2490,24 @@ async fn service_worker_module_rejects_async_dependencies_before_execution() {async fn service_worker_module_checks_only_wasm_evaluation_dependencies() {ensure_v8();for source_only in [false, true] {- let (base_url, server) = spawn_path_response_http_server(vec![- (- "/worker/worker.wasm",- "HTTP/1.1 200 OK",- "application/wasm",- worker_wasm_import_pm_body(),- Duration::ZERO,- ),- (+ let mut responses = vec![(+ "/worker/worker.wasm",+ "HTTP/1.1 200 OK",+ "application/wasm",+ worker_wasm_import_pm_body(),+ Duration::ZERO,+ )];+ if !source_only {+ responses.push(("/worker/worker-helper.js","HTTP/1.1 200 OK","text/javascript","console.log('unexpected helper execution'); export function pm() {} await 0;".into(),Duration::ZERO,- ),- ])- .await;+ ));+ }+ let (base_url, server) = spawn_path_response_http_server(responses).await;let source = if source_only {"import source wasm from './worker.wasm'; console.log(wasm instanceof WebAssembly.Module);"} else {diff --git a/moli-renderer-v8/src/worker/thread/tests/modules/source_phase.rs b/moli-renderer-v8/src/worker/thread/tests/modules/source_phase.rsnew file mode 100644index 000000000..2d472b5cf--- /dev/null+++ b/moli-renderer-v8/src/worker/thread/tests/modules/source_phase.rs@@ -0,0 +1,349 @@+use super::*;+use tokio::net::TcpStream;++// Keep responses under the test's control: a source import must settle even+// while the evaluation graph's dependency response is withheld.+struct ModuleSourceServer {+ url: String,+ requests: tokio::sync::mpsc::UnboundedReceiver<(String, TcpStream)>,+ task: JoinHandle<()>,+}++impl ModuleSourceServer {+ async fn start() -> Self {+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();+ let url = format!("http://{}", listener.local_addr().unwrap());+ let (sender, requests) = tokio::sync::mpsc::unbounded_channel();+ let task = tokio::spawn(async move {+ loop {+ let (mut stream, _) = listener.accept().await.unwrap();+ let head = read_http_request_head(&mut stream).await.unwrap();+ let path = head+ .lines()+ .next()+ .unwrap()+ .split_whitespace()+ .nth(1)+ .unwrap();+ if sender.send((path.to_owned(), stream)).is_err() {+ break;+ }+ }+ });+ Self {+ url,+ requests,+ task,+ }+ }++ fn worker(&self, source: String, kind: WorkerScriptKind) -> WorkerTestHandle {+ spawn_worker_with_request_client_and_kind(+ source,+ format!("{}/worker/main.js", self.url),+ worker_test_request_client(),+ kind,+ )+ }++ async fn request(&mut self, path: &str) -> TcpStream {+ let (actual, stream) = timeout(TIMEOUT, self.requests.recv())+ .await+ .unwrap()+ .unwrap();+ assert_eq!(actual, path);+ stream+ }++ async fn respond(&mut self, path: &str, status: &str, mime: &str, body: &str) {+ Self::write(self.request(path).await, status, mime, body).await;+ }++ async fn write(mut stream: TcpStream, status: &str, mime: &str, body: &str) {+ let response = format!(+ "HTTP/1.1 {status}\r\nContent-Type: {mime}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",+ body.len()+ );+ stream.write_all(response.as_bytes()).await.unwrap();+ }++ async fn wasm(&mut self) {+ self.respond(+ "/worker/worker.wasm",+ "200 OK",+ "application/wasm",+ &worker_wasm_import_pm_body(),+ )+ .await;+ }++ fn assert_no_more_requests(&mut self) {+ assert!(self.requests.try_recv().is_err(), "unexpected module fetch");+ }+}++impl Drop for ModuleSourceServer {+ fn drop(&mut self) {+ self.task.abort();+ }+}++#[tokio::test]+async fn worker_source_imports_do_not_load_wasm_dependencies() {+ ensure_v8();+ for (kind, static_import) in [+ (WorkerScriptKind::Module, true),+ (WorkerScriptKind::Module, false),+ (WorkerScriptKind::Classic, false),+ ] {+ let mut server = ModuleSourceServer::start().await;+ let (prefix, source) = if static_import {+ ("import source wasm from './worker.wasm';", "")+ } else {+ ("", "const wasm = await import.source('./worker.wasm');")+ };+ let mut handle = server.worker(format!(r#"+ {prefix}+ (async () => {{+ {source}+ let value;+ new WebAssembly.Instance(wasm, {{ "./worker-helper.js": {{ pm: v => value = v }} }});+ const again = await import.source('./worker.wasm');+ postMessage([wasm instanceof WebAssembly.Module, value, wasm === again]);+ }})().catch(e => postMessage({{error: e.name}}));+ "#), kind);+ server.wasm().await;+ assert_eq!(recv_post_json(&mut handle).await, "[true,42,true]");+ handle.terminate_and_join();+ server.assert_no_more_requests();+ }+}++#[tokio::test]+async fn worker_source_import_allows_later_evaluation_of_cached_wasm() {+ ensure_v8();+ let mut server = ModuleSourceServer::start().await;+ let mut handle = server.worker(r#"+ (async () => {+ const source = await import.source('./worker.wasm');+ const first = await import('./worker.wasm');+ const second = await import('./worker.wasm');+ const again = await import.source('./worker.wasm');+ postMessage([source === again, first === second, self.evaluationValue, self.evaluations]);+ })().catch(e => postMessage({error: e.name}));+ "#.into(), WorkerScriptKind::Module);+ server.wasm().await;+ server.respond("/worker/worker-helper.js", "200 OK", "text/javascript",+ "self.evaluations = (self.evaluations || 0) + 1; export function pm(v) { self.evaluationValue = v; }").await;+ assert_eq!(recv_post_json(&mut handle).await, "[true,true,42,1]");+ handle.terminate_and_join();+ server.assert_no_more_requests();+}++#[tokio::test]+async fn worker_concurrent_source_imports_do_not_wait_for_evaluation_dependencies() {+ ensure_v8();+ for order in ["source-first", "evaluation-first", "late-source"] {+ let mut server = ModuleSourceServer::start().await;+ let start = match order {+ "source-first" => "const source = loadSource(); const evaluation = loadEvaluation();",+ "evaluation-first" => {+ "const evaluation = loadEvaluation(); const source = loadSource();"+ }+ _ => {+ "const evaluation = loadEvaluation(); await new Promise(r => onmessage = r); const source = loadSource();"+ }+ };+ let mut handle = server.worker(format!(r#"+ (async () => {{+ const loadSource = () => Promise.all([+ import.source('./worker.wasm'), import.source('./worker.wasm')+ ]).then(([a, b]) => {{+ postMessage(['source', a === b, a instanceof WebAssembly.Module]);+ return a;+ }});+ const loadEvaluation = () => Promise.all([+ import('./worker.wasm'), import('./worker.wasm')+ ]).then(([a, b]) => a === b);+ {start}+ const [wasm, sameNamespace] = await Promise.all([source, evaluation]);+ postMessage([sameNamespace, self.evaluationValue, wasm === await import.source('./worker.wasm')]);+ }})().catch(e => postMessage({{error: e.name}}));+ "#), WorkerScriptKind::Module);+ server.wasm().await;+ let dependency = server.request("/worker/worker-helper.js").await;+ if order == "late-source" {+ handle.post_message(serialize_test_string("load source"));+ }+ assert_eq!(+ recv_post_json(&mut handle).await,+ r#"["source",true,true]"#,+ "{order}"+ );+ ModuleSourceServer::write(+ dependency,+ "200 OK",+ "text/javascript",+ "export function pm(v) { self.evaluationValue = v; }",+ )+ .await;+ assert_eq!(+ recv_post_json(&mut handle).await,+ "[true,42,true]",+ "{order}"+ );+ handle.terminate_and_join();+ server.assert_no_more_requests();+ }+}++#[tokio::test]+async fn worker_source_import_survives_concurrent_evaluation_graph_failure() {+ ensure_v8();+ for (status, body, expected_error) in [+ ("404 Not Found", "missing", "TypeError"),+ ("200 OK", "export function {", "TypeError"),+ (+ "200 OK",+ "export function pm() {} throw new Error('evaluation failed');",+ "Error",+ ),+ ] {+ for source_first in [true, false] {+ let mut server = ModuleSourceServer::start().await;+ let start = if source_first {+ "const source = import.source('./worker.wasm'); const evaluation = loadEvaluation();"+ } else {+ "const evaluation = loadEvaluation(); const source = import.source('./worker.wasm');"+ };+ let mut handle = server.worker(format!(r#"+ (async () => {{+ const loadEvaluation = () => import('./worker.wasm').then(() => 'unexpected', e => e.name);+ {start}+ const [wasm, error] = await Promise.all([source, evaluation]);+ let value;+ new WebAssembly.Instance(wasm, {{ './worker-helper.js': {{ pm: v => value = v }} }});+ postMessage([error, value, wasm === await import.source('./worker.wasm')]);+ }})().catch(e => postMessage({{error: e.name}}));+ "#), WorkerScriptKind::Module);+ server.wasm().await;+ server+ .respond("/worker/worker-helper.js", status, "text/javascript", body)+ .await;+ assert_eq!(+ recv_post_json(&mut handle).await,+ format!(r#"["{expected_error}",42,true]"#)+ );+ handle.terminate_and_join();+ server.assert_no_more_requests();+ }+ }+}++#[tokio::test]+async fn worker_source_import_can_reuse_wasm_after_failed_evaluation_loading() {+ ensure_v8();+ let mut server = ModuleSourceServer::start().await;+ let mut handle = server.worker(+ r#"+ (async () => {+ const error = await import('./worker.wasm').then(() => 'unexpected', e => e.name);+ const wasm = await import.source('./worker.wasm');+ let value;+ new WebAssembly.Instance(wasm, { './worker-helper.js': { pm: v => value = v } });+ postMessage([error, value]);+ })().catch(e => postMessage({error: e.name}));+ "#+ .into(),+ WorkerScriptKind::Module,+ );+ server.wasm().await;+ server+ .respond(+ "/worker/worker-helper.js",+ "404 Not Found",+ "text/javascript",+ "missing",+ )+ .await;+ assert_eq!(recv_post_json(&mut handle).await, r#"["TypeError",42]"#);+ handle.terminate_and_join();+ server.assert_no_more_requests();+}++#[tokio::test]+async fn worker_imports_do_not_expand_an_unrelated_failed_graph() {+ ensure_v8();+ let mut server = ModuleSourceServer::start().await;+ let mut handle = server.worker(+ r#"+ (async () => {+ const error = await import('./broken.js').then(() => 'unexpected', e => e.name);+ const wasm = await import.source('./worker.wasm');+ const { value } = await import('./clean.js');+ postMessage([error, wasm instanceof WebAssembly.Module, value]);+ })().catch(e => postMessage({error: e.name}));+ "#+ .into(),+ WorkerScriptKind::Module,+ );+ server+ .respond(+ "/worker/broken.js",+ "200 OK",+ "text/javascript",+ "import './missing.js';",+ )+ .await;+ server+ .respond(+ "/worker/missing.js",+ "404 Not Found",+ "text/javascript",+ "missing",+ )+ .await;+ server.wasm().await;+ server+ .respond(+ "/worker/clean.js",+ "200 OK",+ "text/javascript",+ "export const value = 7;",+ )+ .await;+ assert_eq!(recv_post_json(&mut handle).await, r#"["TypeError",true,7]"#);+ handle.terminate_and_join();+ server.assert_no_more_requests();+}++#[tokio::test]+async fn worker_source_and_evaluation_imports_share_root_fetch_failures() {+ ensure_v8();+ for (status, body) in [("404 Not Found", "missing"), ("200 OK", "invalid wasm")] {+ for source_first in [true, false] {+ let mut server = ModuleSourceServer::start().await;+ let imports = if source_first {+ "[import.source('./worker.wasm'), import('./worker.wasm')]"+ } else {+ "[import('./worker.wasm'), import.source('./worker.wasm')]"+ };+ let mut handle = server.worker(format!(r#"+ (async () => {{+ const results = await Promise.allSettled({imports});+ const again = await import.source('./worker.wasm').then(() => 'unexpected', e => e.name);+ postMessage([results.map(r => [r.status, r.reason.name]), again]);+ }})().catch(e => postMessage({{error: e.name}}));+ "#), WorkerScriptKind::Module);+ server+ .respond("/worker/worker.wasm", status, "application/wasm", body)+ .await;+ assert_eq!(+ recv_post_json(&mut handle).await,+ r#"[[["rejected","TypeError"],["rejected","TypeError"]],"TypeError"]"#+ );+ handle.terminate_and_join();+ server.assert_no_more_requests();+ }+ }+}