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(fetch): preserve RequestInit conversion exceptions
ldm0bc64742a6efd
diff --git a/moli-renderer-v8/src/network_host.rs b/moli-renderer-v8/src/network_host.rsindex 54363283a..b0722c462 100644--- a/moli-renderer-v8/src/network_host.rs+++ b/moli-renderer-v8/src/network_host.rs@@ -123,6 +123,7 @@ pub(crate) use self::media::{start_media_element_resource_fetch,};pub(in crate::network_host) use self::preflight_events::CorsPreflightNetworkObserver;+pub(crate) use self::request::convert_fetch_arguments;pub(in crate::network_host) use self::request::normalize_request_method;pub(crate) use self::request::request_constructor_callback;pub(crate) use self::request::{diff --git a/moli-renderer-v8/src/network_host/fetch/bindings.rs b/moli-renderer-v8/src/network_host/fetch/bindings.rsindex 0b9bde8bd..fd9460031 100644--- a/moli-renderer-v8/src/network_host/fetch/bindings.rs+++ b/moli-renderer-v8/src/network_host/fetch/bindings.rs@@ -151,26 +151,21 @@ pub(crate) fn window_fetch_callback<'s>(// caller's realm is still current. Besides choosing the right realm for// conversion failures, this permits getters to run; the frozen receiver// is revalidated only after all such author code has completed.- let mut parsed = match parse_window_fetch_input(scope, &args) {+ let (mut parsed, signal) = match convert_fetch_arguments(scope, |scope| {+ let parsed = parse_window_fetch_input(scope, &args)?;+ let signal = window_fetch_signal_value(scope, &args)?+ .map(|value| validate_window_fetch_signal(scope, unsafe { &mut *host_ptr }, value))+ .transpose()?+ .flatten()+ .map(|signal| v8::Global::new(scope, signal));+ Ok((parsed, signal))+ }) {Ok(parsed) => parsed,- Err(message) => {- rv.set(make_rejected_promise(scope, &message).into());+ Err(exception) => {+ rv.set(make_rejected_promise_with_value(scope, exception).into());return;}};- let signal_value = window_fetch_signal_value(scope, &args);- let signal = match signal_value {- Some(value) => {- match validate_window_fetch_signal(scope, unsafe { &mut *host_ptr }, value) {- Ok(signal) => signal,- Err(message) => {- rv.set(make_rejected_promise(scope, &message).into());- return;- }- }- }- None => None,- };let Some(binding) = receiver.resolve_live_binding(unsafe { &*host_ptr }) else {// This also catches the subtle generation race where a RequestInit@@ -190,7 +185,6 @@ pub(crate) fn window_fetch_callback<'s>(mark_request_input_body_used_for_fetch(scope, request_body_owner);}let fetch_context = crate::native_bridge::WindowFetchContext::from_realm(binding);- let signal = signal.map(|signal| v8::Global::new(scope, signal));let relevant_context = {let context = fetch_context.script_realm().context(scope);v8::Global::new(scope, context)@@ -359,18 +353,23 @@ fn window_fetch_callback_in_relevant_realm<'s>(fn window_fetch_signal_value<'s>(scope: &mut v8::PinScope<'s, '_>,args: &v8::FunctionCallbackArguments<'s>,-) -> Option<v8::Local<'s, v8::Value>> {+) -> Result<Option<v8::Local<'s, v8::Value>>, String> {let signal_key = v8str(scope, "signal");if args.length() > 1 {let init_arg = args.get(1);if !init_arg.is_null_or_undefined()&& let Ok(init) = v8::Local::<v8::Object>::try_from(init_arg)- && init.has(scope, signal_key.into()).unwrap_or(false)+ && init+ .has(scope, signal_key.into())+ .ok_or("Failed to read RequestInit.signal")?{- let value = init- .get(scope, signal_key.into())- .unwrap_or_else(|| v8::undefined(scope).into());- return Some(value);+ return crate::webidl::property_result(+ scope,+ init,+ "signal",+ crate::webidl::Context::member("RequestInit", "signal"),+ )+ .map_err(|error| error.to_string());}}@@ -378,12 +377,17 @@ fn window_fetch_signal_value<'s>(if !request_like.is_null_or_undefined()&& request_like.is_object()&& let Ok(request_like) = v8::Local::<v8::Object>::try_from(request_like)- && let Some(value) = request_like.get(scope, signal_key.into()){- return Some(value);+ return crate::webidl::property_result(+ scope,+ request_like,+ "signal",+ crate::webidl::Context::member("Request", "signal"),+ )+ .map_err(|error| error.to_string());}- None+ Ok(None)}fn validate_window_fetch_signal<'s>(diff --git a/moli-renderer-v8/src/network_host/request.rs b/moli-renderer-v8/src/network_host/request.rsindex 5d69b7d75..645e2f00e 100644--- a/moli-renderer-v8/src/network_host/request.rs+++ b/moli-renderer-v8/src/network_host/request.rs@@ -8,6 +8,7 @@ use super::headers::{use super::*;pub(crate) use self::bindings::request_constructor_callback;+pub(crate) use self::init::convert_fetch_arguments;pub(in crate::network_host) use self::init::request_credentials_mode_label;pub(crate) use self::init::{parse_fetch_init, request_object_credentials_mode};pub(crate) use self::init::{parse_request_redirect_mode_label, request_redirect_mode_label};diff --git a/moli-renderer-v8/src/network_host/request/init.rs b/moli-renderer-v8/src/network_host/request/init.rsindex 0e42573ba..6e24cd534 100644--- a/moli-renderer-v8/src/network_host/request/init.rs+++ b/moli-renderer-v8/src/network_host/request/init.rs@@ -4,6 +4,30 @@ use crate::webidl;use moli_fetch::{FetchPriorityHint, RequestCredentialsMode, RequestMode, RequestRedirectMode};use std::str::FromStr;+/// Fetch rejects with the original conversion exception, including primitive+/// values. Keep the catch boundary around argument conversion, before a body+/// is consumed or any request is dispatched.+pub(crate) fn convert_fetch_arguments<'s, T>(+ scope: &mut v8::PinScope<'s, '_>,+ convert: impl FnOnce(&mut v8::PinScope<'s, '_>) -> Result<T, String>,+) -> Result<T, v8::Local<'s, v8::Value>> {+ let try_catch = std::pin::pin!(v8::TryCatch::new(scope));+ let mut conversion_scope = try_catch.init();+ let result = convert(&mut conversion_scope);+ if conversion_scope.has_caught() {+ let exception = conversion_scope+ .exception()+ .unwrap_or_else(|| v8::undefined(&conversion_scope).into());+ conversion_scope.reset();+ return Err(exception);+ }+ result.map_err(|message| {+ crate::util::v8_string(&conversion_scope, &message)+ .map(|message| v8::Exception::type_error(&conversion_scope, message))+ .unwrap_or_else(|| v8::undefined(&conversion_scope).into())+ })+}+#[derive(Debug, Clone)]pub(crate) struct ParsedFetchInit {pub(crate) method: String,@@ -96,9 +120,15 @@ fn request_init_headers_member<'s>(object: v8::Local<'s, v8::Object>,_key: &str,) -> Result<Option<Vec<(String, String)>>, webidl::WebIdlError> {- webidl::property_non_nullish(scope, object, "headers")- .map(|headers| headers_entries_from_init(scope, headers).map(Some))- .unwrap_or(Ok(None))+ webidl::property_result(+ scope,+ object,+ "headers",+ webidl::Context::member("RequestInit", "headers"),+ )?+ .filter(|value| !value.is_null_or_undefined())+ .map(|headers| headers_entries_from_init(scope, headers).map(Some))+ .unwrap_or(Ok(None))}pub(crate) fn parse_fetch_init<'s>(diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr.rs b/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr.rsindex a1a15a84f..b5ca6c122 100644--- a/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr.rs+++ b/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr.rs@@ -7072,3 +7072,70 @@ async fn blob_url_revocation_uses_window_and_worker_creator_storage_keys() {}}).await;}++#[tokio::test]+async fn request_init_exceptions_preserve_identity_without_fetching_or_consuming_input() {+ run_page_vm_async_test(async move {+ for worker in [false, true] {+ let mut page_vm = test_page_vm();+ let local_executor = page_vm.local_executor.clone();+ let probe = r#"(async () => {+ const check = (value, message) => { if (!value) throw new Error(message); };+ const url = 'data:text/plain,must-not-fetch';+ for (const api of ['Request', 'fetch']) {+ for (const member of ['method', 'headers', 'signal']) {+ for (const sentinel of [undefined, null, false, 0, 'sentinel', {}, new Error('sentinel')]) {+ const input = new Request(url, {method:'POST', body:'kept'});+ const init = {};+ Object.defineProperty(init, member, {get() { throw sentinel; }});+ let result, caught, threw = false;+ try { result = api === 'Request' ? new Request(input, init) : fetch(input, init); }+ catch (error) { threw = true; caught = error; }+ if (api === 'Request') {+ check(threw && Object.is(caught, sentinel), 'Request must rethrow ' + member);+ } else {+ check(!threw && result instanceof Promise, 'fetch conversion must return a Promise');+ let rejected = false;+ await result.then(() => {}, error => { rejected = true; caught = error; });+ check(rejected && Object.is(caught, sentinel), 'fetch must reject with original ' + member);+ }+ check(!input.bodyUsed, 'failed ' + member + ' conversion consumed input body');+ }+ }+ }+ if (typeof document !== 'undefined') {+ const frame = document.createElement('iframe');+ document.body.appendChild(frame);+ const other = frame.contentWindow;+ const sentinel = new other.Error('cross-realm');+ const promise = other.fetch.call(window, url, {get headers() { throw sentinel; }});+ check(promise instanceof other.Promise, 'conversion rejection must belong to function realm');+ let caught;+ await promise.catch(error => { caught = error; });+ check(caught === sentinel, 'cross-realm exception identity');+ frame.remove();+ }+ return 'ok';+ })()"#;+ let script = if worker {+ let source = serde_json::to_string(&format!("{probe}.then(postMessage, error => postMessage(String(error)))")).unwrap();+ format!(r#"globalThis.__initExceptionResult = 'pending';+ const source = URL.createObjectURL(new Blob([{source}]));+ const worker = new Worker(source);+ worker.onmessage = e => {{ globalThis.__initExceptionResult = e.data; worker.terminate(); URL.revokeObjectURL(source); }};+ worker.onerror = e => {{ globalThis.__initExceptionResult = e.message; }};"#)+ } else {+ format!("globalThis.__initExceptionResult = 'pending'; {probe}.then(value => {{ globalThis.__initExceptionResult = value; }}, error => {{ globalThis.__initExceptionResult = String(error); }})")+ };+ let (result, network_output) = local_executor.run(async move {+ page_vm.vm_mut().eval(&script)?;+ drive_websocket_until_done(&mut page_vm, "String(globalThis.__initExceptionResult !== 'pending')", "RequestInit exception checks should finish").await?;+ let result = page_vm.vm_mut().eval("globalThis.__initExceptionResult")?;+ Ok::<_, anyhow::Error>((result, page_vm.vm_mut().take_network_output()))+ }).await.expect("RequestInit exceptions should run on owner lane");+ assert_eq!(result, "ok", "worker={worker}");+ let (records, _, _) = split_network_output_items(network_output);+ assert!(records.iter().all(|record| record.resource_type() != SubresourceResourceType::Fetch), "failed argument conversion dispatched a fetch; worker={worker}");+ }+ }).await;+}diff --git a/moli-renderer-v8/src/worker/global_scope/fetch.rs b/moli-renderer-v8/src/worker/global_scope/fetch.rsindex dbc60413b..1d10ac0d7 100644--- a/moli-renderer-v8/src/worker/global_scope/fetch.rs+++ b/moli-renderer-v8/src/worker/global_scope/fetch.rs@@ -1,4 +1,5 @@use super::*;+use crate::network_host::convert_fetch_arguments;use crate::service_worker_runtime::{ServiceWorkerClientId, ServiceWorkerDirectFetchResult, ServiceWorkerFetchDispatch,ServiceWorkerFetchRequest, ServiceWorkerFetchRequestMetadata, ServiceWorkerRequestDestination,@@ -1799,16 +1800,29 @@ pub(in crate::worker) fn worker_fetch_signal_option<'s>(let init_arg = args.get(1);if !init_arg.is_null_or_undefined()&& let Ok(init) = v8::Local::<v8::Object>::try_from(init_arg)- && init.has(scope, signal_key.into()).unwrap_or(false)+ && init+ .has(scope, signal_key.into())+ .ok_or("Failed to read RequestInit.signal")?{- let signal = init- .get(scope, signal_key.into())- .unwrap_or_else(|| v8::undefined(scope).into());+ let signal = webidl::property_result(+ scope,+ init,+ "signal",+ webidl::Context::member("RequestInit", "signal"),+ )+ .map_err(|error| error.to_string())?+ .unwrap_or_else(|| v8::undefined(scope).into());return validate_worker_fetch_signal(scope, signal);}}if let Some(request_like) = request_like- && let Some(signal) = request_like.get(scope, signal_key.into())+ && let Some(signal) = webidl::property_result(+ scope,+ request_like,+ "signal",+ webidl::Context::member("Request", "signal"),+ )+ .map_err(|error| error.to_string())?{return validate_worker_fetch_signal(scope, signal);}@@ -2036,10 +2050,12 @@ pub(in crate::worker) fn worker_fetch_callback<'s>(priority,metadata: request_metadata,signal,- } = match resolve_worker_fetch_input(scope, &args, &document_url) {+ } = match convert_fetch_arguments(scope, |scope| {+ resolve_worker_fetch_input(scope, &args, &document_url)+ }) {Ok(resolved) => resolved,- Err(message) => {- rv.set(make_rejected_promise(scope, &message).into());+ Err(exception) => {+ rv.set(make_rejected_promise_with_value(scope, exception).into());return;}};