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(webstorage): preserve StorageEvent WebIDL initialization
ldm0b9fc881f87bf
diff --git a/moli-renderer-v8/src/context_bootstrap/event_legacy.rs b/moli-renderer-v8/src/context_bootstrap/event_legacy.rsindex c85ba88e0..c7a32bda4 100644--- a/moli-renderer-v8/src/context_bootstrap/event_legacy.rs+++ b/moli-renderer-v8/src/context_bootstrap/event_legacy.rs@@ -49,16 +49,16 @@ struct InitStorageEventArgs<'s> {bubbles: bool,#[webidl(default = false)]cancelable: bool,- #[webidl(index = 3, nullable)]- key: Option<String>,- #[webidl(name = "oldValue", index = 4, nullable)]- old_value: Option<String>,- #[webidl(name = "newValue", index = 5, nullable)]- new_value: Option<String>,+ #[webidl(index = 3, nullable, converter = "raw")]+ key: Option<webidl::DomString16>,+ #[webidl(name = "oldValue", index = 4, nullable, converter = "raw")]+ old_value: Option<webidl::DomString16>,+ #[webidl(name = "newValue", index = 5, nullable, converter = "raw")]+ new_value: Option<webidl::DomString16>,#[webidl(default = "", index = 6, converter = "usv_string")]url: String,#[webidl(index = 7, converter = "raw", nullable)]- storage_area: Option<v8::Local<'s, v8::Value>>,+ storage_area: Option<super::web_storage::StorageReference<'s>>,}#[derive(webidl::WebIdlArgs)]@@ -508,14 +508,14 @@ pub(super) fn storage_event_init_callback<'s>() {return;}- super::events::define_storage_event_properties(+ super::events::define_storage_event_properties_utf16(scope,event,- parsed.key.as_deref(),- parsed.old_value.as_deref(),- parsed.new_value.as_deref(),+ parsed.key.as_ref().map(|value| value.0.as_slice()),+ parsed.old_value.as_ref().map(|value| value.0.as_slice()),+ parsed.new_value.as_ref().map(|value| value.0.as_slice()),&parsed.url,- parsed.storage_area,+ parsed.storage_area.map(|value| value.0.into()),);}diff --git a/moli-renderer-v8/src/context_bootstrap/events.rs b/moli-renderer-v8/src/context_bootstrap/events.rsindex dca93b5b6..230047aec 100644--- a/moli-renderer-v8/src/context_bootstrap/events.rs+++ b/moli-renderer-v8/src/context_bootstrap/events.rs@@ -1,5 +1,5 @@use super::*;-use crate::util::{get_private_value, utf16_units, v8_string, v8_string_from_utf16_units, v8str};+use crate::util::{get_private_value, v8_string, v8_string_from_utf16_units, v8str};use moli_webapi_declare::{ObjectLiteralDeclaration, WebApiObject};mod base;@@ -181,29 +181,6 @@ pub(crate) fn construct_original_storage_event_utf16<'s>(Some(event)}-pub(in crate::context_bootstrap) fn define_storage_event_properties<'s>(- scope: &mut v8::PinScope<'s, '_>,- event: v8::Local<'s, v8::Object>,- key: Option<&str>,- old_value: Option<&str>,- new_value: Option<&str>,- url: &str,- storage_area: Option<v8::Local<'s, v8::Value>>,-) {- let key = key.map(utf16_units);- let old_value = old_value.map(utf16_units);- let new_value = new_value.map(utf16_units);- define_storage_event_properties_utf16(- scope,- event,- key.as_deref(),- old_value.as_deref(),- new_value.as_deref(),- url,- storage_area,- );-}-pub(in crate::context_bootstrap) fn define_storage_event_properties_utf16<'s>(scope: &mut v8::PinScope<'s, '_>,event: v8::Local<'s, v8::Object>,diff --git a/moli-renderer-v8/src/context_bootstrap/events/subclasses/constructor.rs b/moli-renderer-v8/src/context_bootstrap/events/subclasses/constructor.rsindex 1d96815c2..15f7326d9 100644--- a/moli-renderer-v8/src/context_bootstrap/events/subclasses/constructor.rs+++ b/moli-renderer-v8/src/context_bootstrap/events/subclasses/constructor.rs@@ -42,7 +42,18 @@ fn event_subclass_constructor_callback<'s>(init_arg.to_object(scope)}};- let (bubbles, cancelable, composed) = read_event_init(scope, &args);+ let storage_event_init = if kind == EventSubclassKind::StorageEvent {+ let Some(init) = data::parse_storage_event_init(scope, &args) else {+ return;+ };+ Some(init)+ } else {+ None+ };+ let (bubbles, cancelable, composed) = storage_event_init+ .as_ref()+ .map(data::StorageEventInitMembers::event_flags)+ .unwrap_or_else(|| read_event_init(scope, &args));initialize_event_object_with_type(scope, event, event_type, bubbles, cancelable);define_event_property(@@ -113,9 +124,11 @@ fn event_subclass_constructor_callback<'s>(}EventSubclassKind::MessageEvent => data::initialize_message_event(scope, event, init),EventSubclassKind::StorageEvent => {- if !data::initialize_storage_event(scope, event, init) {- return;- }+ data::initialize_storage_event(+ scope,+ event,+ storage_event_init.expect("StorageEvent init should be parsed"),+ );}EventSubclassKind::ErrorEvent => data::initialize_error_event(scope, event, init),EventSubclassKind::PromiseRejectionEvent => {diff --git a/moli-renderer-v8/src/context_bootstrap/events/subclasses/data.rs b/moli-renderer-v8/src/context_bootstrap/events/subclasses/data.rsindex 11ed91b8d..32e19e4f2 100644--- a/moli-renderer-v8/src/context_bootstrap/events/subclasses/data.rs+++ b/moli-renderer-v8/src/context_bootstrap/events/subclasses/data.rs@@ -10,6 +10,7 @@ use crate::context_bootstrap::navigation_handler_callbacks::{use crate::context_bootstrap::navigation_window::{child_browsing_context_handle_for_runtime_owner, runtime_window_is_global, runtime_window_owner,};+use crate::context_bootstrap::web_storage::StorageReference;use crate::native_bridge::element::scroll_to_url_fragment_or_top;use crate::native_bridge::throw_dom_exception;use crate::util::context_host_ptr_from_global_bridge;@@ -314,17 +315,47 @@ struct ToggleEventInitMembers<'s> {#[derive(Default, webidl::WebIdlDictionary)]#[webidl(prefix = "StorageEventInit")]-struct StorageEventInitMembers<'s> {- #[webidl(nullable)]- key: Option<String>,- #[webidl(name = "oldValue", nullable)]- old_value: Option<String>,- #[webidl(name = "newValue", nullable)]- new_value: Option<String>,+pub(super) struct StorageEventInitMembers<'s> {+ #[webidl(default = false)]+ bubbles: bool,+ #[webidl(default = false)]+ cancelable: bool,+ #[webidl(default = false)]+ composed: bool,+ #[webidl(nullable, converter = "raw")]+ key: Option<webidl::DomString16>,+ #[webidl(name = "newValue", nullable, converter = "raw")]+ new_value: Option<webidl::DomString16>,+ #[webidl(name = "oldValue", nullable, converter = "raw")]+ old_value: Option<webidl::DomString16>,+ #[webidl(name = "storageArea", converter = "raw", nullable)]+ storage_area: Option<StorageReference<'s>>,#[webidl(default = "", converter = "usv_string")]url: String,- #[webidl(name = "storageArea", converter = "raw", nullable)]- storage_area: Option<v8::Local<'s, v8::Value>>,+}++impl StorageEventInitMembers<'_> {+ pub(super) fn event_flags(&self) -> (bool, bool, bool) {+ (self.bubbles, self.cancelable, self.composed)+ }+}++pub(super) fn parse_storage_event_init<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: &v8::FunctionCallbackArguments<'s>,+) -> Option<StorageEventInitMembers<'s>> {+ let parsed = webidl::dictionary_arg(args, 1, webidl::Context::argument("StorageEvent", 2))+ .and_then(|object| match object {+ Some(object) => webidl::parse_dictionary_object(scope, object),+ None => Ok(StorageEventInitMembers::default()),+ });+ match parsed {+ Ok(init) => Some(init),+ Err(error) => {+ webidl::throw_error(scope, &error);+ None+ }+ }}fn toggle_event_source_member<'s>(@@ -482,30 +513,17 @@ pub(in crate::context_bootstrap::events::subclasses) fn initialize_message_eventpub(in crate::context_bootstrap::events::subclasses) fn initialize_storage_event<'s>(scope: &mut v8::PinScope<'s, '_>,event: v8::Local<'s, v8::Object>,- init: Option<v8::Local<'s, v8::Object>>,-) -> bool {- let parsed = match init {- Some(init) => {- match webidl::parse_dictionary_object::<StorageEventInitMembers>(scope, init) {- Ok(parsed) => parsed,- Err(error) => {- webidl::throw_error(scope, &error);- return false;- }- }- }- None => StorageEventInitMembers::default(),- };- crate::context_bootstrap::events::define_storage_event_properties(+ parsed: StorageEventInitMembers<'s>,+) {+ crate::context_bootstrap::events::define_storage_event_properties_utf16(scope,event,- parsed.key.as_deref(),- parsed.old_value.as_deref(),- parsed.new_value.as_deref(),+ parsed.key.as_ref().map(|value| value.0.as_slice()),+ parsed.old_value.as_ref().map(|value| value.0.as_slice()),+ parsed.new_value.as_ref().map(|value| value.0.as_slice()),&parsed.url,- parsed.storage_area,+ parsed.storage_area.map(|value| value.0.into()),);- true}pub(in crate::context_bootstrap::events::subclasses) fn initialize_input_event<'s>(diff --git a/moli-renderer-v8/src/context_bootstrap/web_storage.rs b/moli-renderer-v8/src/context_bootstrap/web_storage.rsindex 5b96e7728..12ebffd59 100644--- a/moli-renderer-v8/src/context_bootstrap/web_storage.rs+++ b/moli-renderer-v8/src/context_bootstrap/web_storage.rs@@ -1,4 +1,25 @@use super::*;+use crate::webidl;++pub(crate) struct StorageReference<'scope>(pub(crate) v8::Local<'scope, v8::Object>);++impl<'scope> webidl::WebIdlConverter<'scope> for StorageReference<'scope> {+ type Options = ();++ fn convert(+ scope: &mut v8::PinScope<'scope, '_>,+ value: v8::Local<'scope, v8::Value>,+ context: webidl::Context,+ _options: &Self::Options,+ ) -> Result<Self, webidl::WebIdlError> {+ if let Ok(object) = v8::Local::<v8::Object>::try_from(value)+ && crate::web_api_interfaces::Storage::is_instance(scope, object)+ {+ return Ok(Self(object));+ }+ Err(webidl::WebIdlError::cannot_convert(context, "Storage"))+ }+}mod accessors;mod callbacks;diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rsindex 4ae3bfb47..8c476d857 100644--- a/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs@@ -49,6 +49,7 @@ mod session_description;mod simple_handler_object;mod speech_synthesis;mod storage_access;+mod storage_event_init;mod structured_clone;mod transferable_streams;mod traversal;diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/storage_event_init.js b/moli-renderer-v8/src/script_vm/tests/browser_api/storage_event_init.jsnew file mode 100644index 000000000..e93448a66--- /dev/null+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/storage_event_init.js@@ -0,0 +1,186 @@+(() => {+ const rows = [];+ const check = (name, run) => {+ try {+ if (run() !== true) throw new Error('assertion failed');+ rows.push({name, passed: true});+ } catch (error) {+ rows.push({name, passed: false, error: String(error), stack: error.stack});+ }+ };+ const throws = (run, expected) => {+ try { run(); } catch (error) { return error === expected; }+ return false;+ };+ const typeError = (run, realm = globalThis) => {+ try { run(); } catch (error) { return error instanceof realm.TypeError; }+ return false;+ };+ const legacy = (key, oldValue, newValue, url, storageArea) => {+ const event = new StorageEvent('before');+ event.initStorageEvent('after', true, true, key, oldValue, newValue, url, storageArea);+ return event;+ };+ const strings = ['', '\ud800', '\udc00', '\ud83d\ude00', 'a\ud800b\udc00\u0000\ud83d\ude00'];+ for (const field of ['key', 'oldValue', 'newValue']) {+ for (let i = 0; i < strings.length; i++) {+ const text = strings[i];+ check(`constructor ${field} UTF-16 ${i}`, () => new StorageEvent('x', {[field]: text})[field] === text);+ check(`legacy ${field} UTF-16 ${i}`, () => legacy(text, text, text, '')[field] === text);+ }+ for (const value of [undefined, null]) {+ check(`constructor ${field} nullable ${String(value)}`, () => new StorageEvent('x', {[field]: value})[field] === null);+ check(`legacy ${field} nullable ${String(value)}`, () => legacy(value, value, value, '')[field] === null);+ }+ check(`constructor ${field} string conversion`, () => {+ let conversions = 0;+ const value = {[Symbol.toPrimitive](hint) { if (hint !== 'string') throw new Error(hint); conversions++; return strings[4]; }};+ const event = new StorageEvent('x', {[field]: value});+ return conversions === 1 && event[field] === strings[4];+ });+ check(`legacy ${field} string conversion`, () => {+ let conversions = 0;+ const value = {toString() { conversions++; return strings[4]; }};+ const values = {key: null, oldValue: null, newValue: null, [field]: value};+ const event = legacy(values.key, values.oldValue, values.newValue, '');+ return conversions === 1 && event[field] === strings[4];+ });+ check(`constructor ${field} Symbol rejects`, () => typeError(() => new StorageEvent('x', {[field]: Symbol()})));+ check(`legacy ${field} Symbol rejects`, () => {+ const values = {key: null, oldValue: null, newValue: null, [field]: Symbol()};+ return typeError(() => legacy(values.key, values.oldValue, values.newValue, ''));+ });+ }+ check('constructor defaults', () => {+ const event = new StorageEvent('x');+ return event.key === null && event.oldValue === null && event.newValue === null && event.url === '' && event.storageArea === null && !event.bubbles && !event.cancelable && !event.composed;+ });+ check('legacy defaults', () => {+ const event = new StorageEvent('before', {key: 'k', oldValue: 'o', newValue: 'n', composed: true});+ const result = event.initStorageEvent('after');+ return result === undefined && event.type === 'after' && event.key === null && event.oldValue === null && event.newValue === null && event.url === '' && event.storageArea === null && event.composed;+ });+ for (const [value, expected] of [[undefined, ''], [null, 'null'], [strings[4], 'a\ufffdb\ufffd\u0000\ud83d\ude00']]) {+ check(`constructor url USVString ${String(value)}`, () => new StorageEvent('x', {url: value}).url === expected);+ check(`legacy url USVString ${String(value)}`, () => legacy(null, null, null, value).url === expected);+ }+ for (const value of [undefined, null]) {+ check(`nullable dictionary ${String(value)}`, () => new StorageEvent('x', value).key === null);+ }+ for (const value of [false, true, 0, 1, '', 'init', Symbol('init'), 1n]) {+ check(`primitive dictionary ${String(value)}`, () => typeError(() => new StorageEvent('x', value)));+ }+ check('function dictionary', () => {+ const init = () => {};+ init.key = strings[4];+ return new StorageEvent('x', init).key === strings[4];+ });+ const order = ['bubbles', 'cancelable', 'composed', 'key', 'newValue', 'oldValue', 'storageArea', 'url'];+ check('inherited then own dictionary order', () => {+ const seen = [];+ new StorageEvent('x', new Proxy({}, {get(_target, name) { seen.push(name); }}));+ return seen.join() === order.join();+ });+ check('dictionary reads and conversions are interleaved once', () => {+ const seen = [];+ const init = new Proxy({}, {get(_target, name) {+ seen.push(`get:${name}`);+ if (['key', 'newValue', 'oldValue', 'url'].includes(name)) {+ return {[Symbol.toPrimitive](hint) { seen.push(`convert:${name}:${hint}`); return strings[4]; }};+ }+ }});+ const event = new StorageEvent('x', init);+ const expected = order.flatMap(name => ['key', 'newValue', 'oldValue', 'url'].includes(name) ? [`get:${name}`, `convert:${name}:string`] : [`get:${name}`]);+ return seen.join() === expected.join() && event.key === strings[4] && event.url === 'a\ufffdb\ufffd\u0000\ud83d\ude00';+ });+ for (const stop of order) {+ check(`dictionary getter exception stops at ${stop}`, () => {+ const sentinel = {};+ const seen = [];+ const init = new Proxy({}, {get(_target, name) { seen.push(name); if (name === stop) throw sentinel; }});+ return throws(() => new StorageEvent('x', init), sentinel) && seen.join() === order.slice(0, order.indexOf(stop) + 1).join();+ });+ }+ for (const stop of ['key', 'newValue', 'oldValue', 'url']) {+ check(`dictionary conversion exception stops at ${stop}`, () => {+ const sentinel = {};+ const seen = [];+ const init = new Proxy({}, {get(_target, name) { seen.push(name); if (name === stop) return {toString() { throw sentinel; }}; }});+ return throws(() => new StorageEvent('x', init), sentinel) && seen.join() === order.slice(0, order.indexOf(stop) + 1).join();+ });+ }+ check('inherited dictionary values retain UTF-16', () => new StorageEvent('x', Object.create({key: strings[4], newValue: strings[1]})).key === strings[4]);+ check('event type converts before dictionary', () => {+ const seen = [];+ const type = {toString() { seen.push('type'); return strings[4]; }};+ const init = new Proxy({}, {get(_target, name) { seen.push(name); }});+ const event = new StorageEvent(type, init);+ return event.type === strings[4] && seen.join() === ['type', ...order].join();+ });+ check('legacy positional conversion order', () => {+ const seen = [];+ const value = name => ({toString() { seen.push(name); return name; }});+ const event = new StorageEvent('before');+ event.initStorageEvent(value('type'), true, true, value('key'), value('oldValue'), value('newValue'), value('url'), null);+ return seen.join() === 'type,key,oldValue,newValue,url' && event.key === 'key' && event.oldValue === 'oldValue' && event.newValue === 'newValue';+ });+ for (const field of ['key', 'oldValue', 'newValue', 'url']) {+ check(`legacy failed ${field} conversion is atomic`, () => {+ const event = new StorageEvent('before', {bubbles: true, composed: true, key: 'k', oldValue: 'o', newValue: 'n', url: 'u'});+ const sentinel = {};+ const seen = [];+ const names = ['key', 'oldValue', 'newValue', 'url'];+ const values = names.map(name => ({toString() { seen.push(name); if (name === field) throw sentinel; return name; }}));+ return throws(() => event.initStorageEvent('after', false, true, ...values, null), sentinel) && seen.join() === names.slice(0, names.indexOf(field) + 1).join() && event.type === 'before' && event.bubbles && !event.cancelable && event.composed && event.key === 'k' && event.oldValue === 'o' && event.newValue === 'n' && event.url === 'u';+ });+ }+ const invalidAreas = [false, 1, 'storage', {}, [], Object.create(Storage.prototype)];+ for (let i = 0; i < invalidAreas.length; i++) {+ const storageArea = invalidAreas[i];+ check(`constructor rejects unbranded storageArea ${i}`, () => typeError(() => new StorageEvent('x', {storageArea})));+ check(`legacy rejects unbranded storageArea ${i} before mutation`, () => {+ const event = new StorageEvent('before', {key: 'keep'});+ return typeError(() => event.initStorageEvent('after', false, false, null, null, null, '', storageArea)) && event.type === 'before' && event.key === 'keep';+ });+ }+ check('invalid storageArea stops before url getter', () => {+ let reads = 0;+ return typeError(() => new StorageEvent('x', {storageArea: {}, get url() { reads++; return ''; }})) && reads === 0;+ });+ const other = document.getElementById('child').contentWindow;+ check('constructor conversion TypeError uses callee realm', () => typeError(() => new other.StorageEvent('x', {key: Symbol()}), other));+ check('legacy conversion TypeError uses callee realm', () => typeError(() => other.StorageEvent.prototype.initStorageEvent.call(new StorageEvent('x'), 'x', false, false, Symbol()), other));+ check('constructor storageArea TypeError uses callee realm', () => typeError(() => new other.StorageEvent('x', {storageArea: {}}), other));+ check('legacy rejects forged receiver before converting arguments', () => {+ let conversions = 0;+ const type = {toString() { conversions++; return 'x'; }};+ return typeError(() => StorageEvent.prototype.initStorageEvent.call(Object.create(StorageEvent.prototype), type)) && conversions === 0;+ });+ check('legacy dispatch guard follows conversion and preserves state', () => {+ const target = new EventTarget();+ const event = new StorageEvent('storage', {key: 'keep'});+ let conversions = 0;+ target.addEventListener('storage', current => {+ current.initStorageEvent('after', true, true, {toString() { conversions++; return strings[4]; }});+ });+ target.dispatchEvent(event);+ return conversions === 1 && event.type === 'storage' && event.key === 'keep' && !event.bubbles && !event.cancelable;+ });+ if (location.protocol !== 'data:') {+ for (const [name, storageArea] of [['local', localStorage], ['session', sessionStorage], ['child', other.localStorage]]) {+ check(`constructor accepts branded ${name} Storage`, () => new StorageEvent('x', {storageArea}).storageArea === storageArea);+ check(`legacy accepts branded ${name} Storage`, () => legacy(null, null, null, '', storageArea).storageArea === storageArea);+ }+ let traps = 0;+ const author = new Proxy(localStorage, {get() { traps++; throw new Error('trap'); }, getPrototypeOf() { traps++; throw new Error('trap'); }});+ const revoked = Proxy.revocable(localStorage, {}); revoked.revoke();+ for (const [name, storageArea] of [['author proxy', author], ['revoked proxy', revoked.proxy], ['inherited instance', Object.create(localStorage)]]) {+ check(`constructor rejects ${name} Storage without traps`, () => typeError(() => new StorageEvent('x', {storageArea})) && traps === 0);+ check(`legacy rejects ${name} Storage without traps`, () => typeError(() => legacy(null, null, null, '', storageArea)) && traps === 0);+ }+ check('cross realm constructor accepts genuine parent Storage', () => new other.StorageEvent('x', {storageArea: localStorage, key: strings[4]}).storageArea === localStorage);+ }+ globalThis.__storageEventResults = {total: rows.length, passed: rows.filter(row => row.passed).length, rows};+ const failed = rows.filter(row => !row.passed);+ return failed.length ? JSON.stringify(failed) : true;+})()diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/storage_event_init.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/storage_event_init.rsnew file mode 100644index 000000000..ab602d384--- /dev/null+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/storage_event_init.rs@@ -0,0 +1,12 @@+use super::*;++#[test]+fn storage_event_initializers_preserve_dom_strings_and_validate_storage_interfaces() {+ let mut vm = new_storage_html_test_vm("https://storage-event-init-webidl.test/");+ vm.eval("document.body.innerHTML = '<iframe id=child></iframe>';")+ .unwrap();+ assert_eq!(+ vm.eval(include_str!("storage_event_init.js")).unwrap(),+ "true"+ );+}