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(indexeddb): expose native version change event attributes
ldm0c1fc9cad91ca
diff --git a/moli-core/tests/web_apis/fixtures/indexeddb-version-change.js b/moli-core/tests/web_apis/fixtures/indexeddb-version-change.jsnew file mode 100644index 000000000..3384a22e5--- /dev/null+++ b/moli-core/tests/web_apis/fixtures/indexeddb-version-change.js@@ -0,0 +1,166 @@+globalThis.versionChangeChecks = [];+async function versionChangeProbe(prefix = 'version-change') {+ const checks = versionChangeChecks;+ const check = (label, pass, actual = '') => checks.push({label, pass, actual: String(actual)});+ const same = (label, actual, expected) => check(label, JSON.stringify(actual) === JSON.stringify(expected), JSON.stringify(actual));+ const throws = (label, action, Realm) => {+ let caught;+ try { action(); } catch (error) { caught = error; }+ check(label, caught !== undefined && Object.getPrototypeOf(caught) === Realm.TypeError.prototype, caught);+ };+ const exercise = async (label, Realm, GetterRealm) => {+ const Ctor = Realm.IDBVersionChangeEvent;+ const getters = {};+ for (const name of ['oldVersion', 'newVersion']) {+ const descriptor = Object.getOwnPropertyDescriptor(GetterRealm.IDBVersionChangeEvent.prototype, name);+ getters[name] = descriptor?.get;+ check(label + ': ' + name + ' descriptor', typeof descriptor?.get === 'function' &&+ descriptor.set === undefined && descriptor.enumerable && descriptor.configurable);+ check(label + ': ' + name + ' getter metadata', descriptor?.get?.name === 'get ' + name && descriptor.get.length === 0);+ }+ const get = (name, receiver) => typeof getters[name] === 'function' ? getters[name].call(receiver) : undefined;+ check(label + ': constructor length', Ctor.length === 1, Ctor.length);+ throws(label + ': new is required', () => Ctor('type'), Realm);+ throws(label + ': type is required', () => new Ctor(), Realm);+ throws(label + ': symbol type is rejected', () => new Ctor(Symbol()), Realm);+ for (const invalid of [1, 'init', Symbol(), 1n]) {+ throws(label + ': primitive dictionary is rejected', () => new Ctor('type', invalid), Realm);+ }+ for (const init of [undefined, null, {}]) {+ const event = new Ctor('default', init);+ same(label + ': default versions', [event.oldVersion, event.newVersion], [0, null]);+ same(label + ': default flags', [event.bubbles, event.cancelable, event.composed, event.isTrusted], [false, false, false, false]);+ }+ const order = [];+ const init = {};+ for (const [name, value] of [['bubbles', true], ['cancelable', true], ['composed', true],+ ['newVersion', {valueOf() { order.push('convert newVersion'); return 9; }}],+ ['oldVersion', {valueOf() { order.push('convert oldVersion'); return 7; }}]]) {+ Object.defineProperty(init, name, {get() { order.push(name); return value; }});+ }+ const event = new Ctor({toString() { order.push('type'); return 'flags'; }}, Object.create(init));+ same(label + ': conversion order', order,+ ['type', 'bubbles', 'cancelable', 'composed', 'newVersion', 'convert newVersion', 'oldVersion', 'convert oldVersion']);+ for (const name of ['bubbles', 'cancelable', 'composed']) {+ check(label + ': EventInit ' + name, event[name] === true, event[name]);+ }+ const target = new EventTarget();+ target.addEventListener('flags', value => value.preventDefault());+ check(label + ': EventInit dispatch cancellation', target.dispatchEvent(event) === false);+ check(label + ': EventInit defaultPrevented', event.defaultPrevented === true);+ for (const [name, expected] of [['oldVersion', 7], ['newVersion', 9]]) {+ check(label + ': ' + name + ' inherited', !Object.hasOwn(event, name));+ check(label + ': ' + name + ' getter value', get(name, event) === expected, get(name, event));+ check(label + ': ' + name + ' readonly', Reflect.set(event, name, 99) === false);+ check(label + ': ' + name + ' unchanged', event[name] === expected, event[name]);+ Object.defineProperty(event, name, {configurable: true, get() { throw new Error('author shadow'); }});+ check(label + ': ' + name + ' native value under author shadow', get(name, event) === expected, get(name, event));+ delete event[name];+ check(label + ': ' + name + ' restored getter', event[name] === expected, event[name]);+ }+ const revoked = Proxy.revocable(event, {}); revoked.revoke();+ let traps = 0;+ const trapped = new Proxy(event, {get() { ++traps; throw new Error('trap'); }, getPrototypeOf() { ++traps; throw new Error('trap'); }});+ for (const receiver of [null, undefined, 1, {}, Ctor.prototype, Object.create(Ctor.prototype),+ Object.create(event), new Realm.Event('base'), new Proxy(event, {}), revoked.proxy, trapped]) {+ for (const name of ['oldVersion', 'newVersion']) {+ throws(label + ': ' + name + ' invalid receiver', () => get(name, receiver), GetterRealm);+ }+ }+ check(label + ': no Proxy traps', traps === 0, traps);+ Object.setPrototypeOf(event, null);+ same(label + ': native identity survives prototype removal', [get('oldVersion', event), get('newVersion', event)], [7, 9]);+ class Subclass extends Ctor {}+ const sub = new Subclass('sub', {oldVersion: 3, newVersion: 4});+ check(label + ': subclass prototype is preserved', Object.getPrototypeOf(sub) === Subclass.prototype);+ same(label + ': subclass native identity', [get('oldVersion', sub), get('newVersion', sub)], [3, 4]);++ const members = ['bubbles', 'cancelable', 'composed', 'newVersion', 'oldVersion'];+ for (let stop = 0; stop < members.length; ++stop) {+ const reads = [];+ const marker = new Error('dictionary getter');+ const options = new Proxy({}, {get(_target, key) {+ reads.push(key);+ if (key === members[stop]) throw marker;+ return undefined;+ }});+ let caught;+ try { new Ctor('throws', options); } catch (error) { caught = error; }+ check(label + ': getter exception identity ' + members[stop], caught === marker, caught);+ same(label + ': stop conversion at ' + members[stop], reads, members.slice(0, stop + 1));+ }+ const conversions = [[undefined, 0, null], [null, 0, null], [NaN, 0, 0], [Infinity, 0, 0],+ [-Infinity, 0, 0], [1.9, 1, 1], [-1, 2 ** 64, 2 ** 64], [2 ** 64, 0, 0], ['12', 12, 12]];+ for (const [value, oldVersion, newVersion] of conversions) {+ const converted = new Ctor('number', {oldVersion: value, newVersion: value});+ same(label + ': numeric conversion ' + String(value), [converted.oldVersion, converted.newVersion], [oldVersion, newVersion]);+ }+ for (const name of ['oldVersion', 'newVersion']) {+ for (const value of [Symbol(), 1n]) {+ throws(label + ': reject invalid ' + name, () => new Ctor('invalid', {[name]: value}), Realm);+ }+ }+ const marker = new Error('type conversion');+ let dictionaryReads = 0;+ let caught;+ try {+ new Ctor({toString() { throw marker; }}, new Proxy({}, {get() { ++dictionaryReads; }}));+ } catch (error) { caught = error; }+ check(label + ': type exception identity', caught === marker);+ check(label + ': type exception stops dictionary conversion', dictionaryReads === 0, dictionaryReads);++ const nativeEvents = [];+ const seen = [];+ let inspectionError;+ const inspectNative = (name, value, oldVersion, newVersion) => {+ try {+ seen.push(name);+ same(label + ': native ' + name + ' versions', [value.oldVersion, value.newVersion], [oldVersion, newVersion]);+ same(label + ': native ' + name + ' flags', [value.bubbles, value.cancelable, value.composed], [false, false, false]);+ check(label + ': native ' + name + ' prototype', Object.getPrototypeOf(value) === Ctor.prototype);+ check(label + ': native ' + name + ' inherited attributes', !Object.hasOwn(value, 'oldVersion') && !Object.hasOwn(value, 'newVersion'));+ same(label + ': native ' + name + ' borrowed getters', [get('oldVersion', value), get('newVersion', value)], [oldVersion, newVersion]);+ check(label + ': native ' + name + ' readonly oldVersion', Reflect.set(value, 'oldVersion', 99) === false);+ check(label + ': native ' + name + ' readonly newVersion', Reflect.set(value, 'newVersion', 99) === false);+ nativeEvents.push([name, value, oldVersion, newVersion]);+ } catch (error) { inspectionError ??= error; }+ };+ const requestResult = request => new Promise((resolve, reject) => {+ request.onsuccess = () => resolve(request.result);+ request.onerror = () => reject(request.error);+ });+ const factory = Realm.indexedDB;+ const name = prefix + '-' + label;+ const savedCtor = Realm.IDBVersionChangeEvent;+ Realm.IDBVersionChangeEvent = function() { throw new Error('author constructor'); };+ try {+ const first = factory.open(name, 1);+ first.onupgradeneeded = value => inspectNative('create', value, 0, 1);+ const oldDb = await requestResult(first);+ oldDb.onversionchange = value => inspectNative('versionchange', value, 1, 2);+ const second = factory.open(name, 2);+ second.onblocked = value => { inspectNative('blocked', value, 1, 2); oldDb.close(); };+ second.onupgradeneeded = value => inspectNative('upgrade', value, 1, 2);+ const newDb = await requestResult(second);+ newDb.onversionchange = value => { inspectNative('delete notification', value, 2, null); newDb.close(); };+ await requestResult(factory.deleteDatabase(name));+ } finally { Realm.IDBVersionChangeEvent = savedCtor; }+ if (inspectionError) throw inspectionError;+ same(label + ': native event order', seen,+ ['create', 'versionchange', 'blocked', 'upgrade', 'delete notification']);+ for (const [name, value, oldVersion, newVersion] of nativeEvents) {+ same(label + ': retained native ' + name, [get('oldVersion', value), get('newVersion', value)], [oldVersion, newVersion]);+ }+ };+ await exercise('local', globalThis, globalThis);+ if (typeof document !== 'undefined') {+ const frame = document.createElement('iframe');+ const loaded = new Promise(resolve => { frame.onload = resolve; });+ frame.srcdoc = '<!doctype html>'; document.documentElement.appendChild(frame); await loaded;+ try {+ await exercise('foreign-getter', globalThis, frame.contentWindow);+ await exercise('foreign-event', frame.contentWindow, globalThis);+ } finally { frame.remove(); }+ }+ return {state: checks.every(check => check.pass) ? 'pass' : 'fail', checks};+}diff --git a/moli-core/tests/web_apis/indexed_db_transaction.rs b/moli-core/tests/web_apis/indexed_db_transaction.rsindex 379b1dda3..e6689b72c 100644--- a/moli-core/tests/web_apis/indexed_db_transaction.rs+++ b/moli-core/tests/web_apis/indexed_db_transaction.rs@@ -1,6 +1,28 @@use super::pipe_disturbed::run_probe;use super::*;+#[tokio::test(flavor = "multi_thread")]+async fn indexed_db_version_change_events_preserve_native_attributes_and_dictionary_semantics()+-> Result<()> {+ let server = FixtureServer::spawn().await?;+ let browser = Browser::new(AppConfig::default())?;+ let fixture = include_str!("fixtures/indexeddb-version-change.js");+ for target in ["window", "child", "worker"] {+ let source = format!(+ "{fixture}\nversionChangeProbe('version-change-{target}').then(finish, error => finish({{state: 'error', error: String(error), checks: versionChangeChecks}}));"+ );+ let result = run_probe(&browser, &server, target, &source).await?;+ assert_eq!(result["state"], "pass", "{target}: {result}");+ assert_eq!(+ result["checks"].as_array().unwrap().len(),+ if target == "worker" { 128 } else { 384 },+ "{target}: {result}"+ );+ }+ server.shutdown().await;+ Ok(())+}+#[tokio::test(flavor = "multi_thread")]async fn indexed_db_factory_checks_native_receivers_and_rejects_promises_in_callee_realm()-> Result<()> {diff --git a/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rs b/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rsindex cec46ed2a..769f2e0a3 100644--- a/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rs+++ b/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rs@@ -938,7 +938,7 @@ pub(in crate::context_bootstrap) fn build_constructor_template<'s>(web_api_interfaces::IDBVersionChangeEvent,crate::context_bootstrap::indexed_db::idb_version_change_event_constructor_callback))- .length(2)+ .length(1).build(scope)}};diff --git a/moli-renderer-v8/src/context_bootstrap/indexed_db/event_target/version_change.rs b/moli-renderer-v8/src/context_bootstrap/indexed_db/event_target/version_change.rsindex d0bb35658..a4faf8335 100644--- a/moli-renderer-v8/src/context_bootstrap/indexed_db/event_target/version_change.rs+++ b/moli-renderer-v8/src/context_bootstrap/indexed_db/event_target/version_change.rs@@ -1,15 +1,62 @@use super::super::super::events;use super::*;+use crate::web_api_interfaces;use crate::webidl;-use moli_webapi_declare::WebApiObject;+use moli_webapi_declare::{WebApiFunctionTemplate, WebApiObject};++const OLD_VERSION_SLOT: &str = "__moli_idb_event_old_version";+const NEW_VERSION_SLOT: &str = "__moli_idb_event_new_version";#[derive(WebApiObject)]-#[webapi(plain, data_properties, enumerable)]+#[webapi(fragment)]struct IdbVersionChangeEventFieldsDeclaration<'scope> {+ #[webapi(slot = OLD_VERSION_SLOT)]old_version: u64,+ #[webapi(slot = NEW_VERSION_SLOT)]new_version: v8::Local<'scope, v8::Value>,}+#[derive(WebApiFunctionTemplate)]+#[webapi(interface = web_api_interfaces::IDBVersionChangeEvent, enumerable, receiver)]+struct IdbVersionChangeEventPrototypeDeclaration {+ #[webapi(accessor_property, getter = old_version_getter)]+ old_version: (),+ #[webapi(accessor_property, getter = new_version_getter)]+ new_version: (),+}++pub(in crate::context_bootstrap::indexed_db) fn install_version_change_event_template_bindings<+ 's,+>(+ scope: &mut v8::PinScope<'s, '_, ()>,+ prototype: v8::Local<'s, v8::ObjectTemplate>,+ name: &str,+) {+ if name == "IDBVersionChangeEvent" {+ IdbVersionChangeEventPrototypeDeclaration::initialize_prototype_template(scope, prototype);+ }+}++fn old_version_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'s, v8::Value>,+) {+ if let Some(value) = events::event_private_value(scope, args.this(), OLD_VERSION_SLOT) {+ rv.set(value);+ }+}++fn new_version_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'s, v8::Value>,+) {+ if let Some(value) = events::event_private_value(scope, args.this(), NEW_VERSION_SLOT) {+ rv.set(value);+ }+}+#[derive(webidl::WebIdlArgs)]#[webidl(prefix = "IDBVersionChangeEvent")]struct IdbVersionChangeEventConstructorArgs {@@ -22,10 +69,18 @@ struct IdbVersionChangeEventConstructorArgs {#[derive(Default, webidl::WebIdlDictionary)]#[webidl(prefix = "IDBVersionChangeEventInit")]struct IdbVersionChangeEventInit {- #[webidl(default = 0)]- old_version: u64,+ // WebIDL reads inherited EventInit members first, then this dictionary's+ // members in lexicographic order. The derive preserves declaration order.+ #[webidl(default = false)]+ bubbles: bool,+ #[webidl(default = false)]+ cancelable: bool,+ #[webidl(default = false)]+ composed: bool,#[webidl(nullable)]new_version: Option<u64>,+ #[webidl(default = 0)]+ old_version: u64,}pub(in crate::context_bootstrap) fn idb_version_change_event_constructor_callback<'s>(@@ -46,7 +101,19 @@ pub(in crate::context_bootstrap) fn idb_version_change_event_constructor_callbac};let wrapper = args.this();let event = events::new_event_state(scope);- events::initialize_event_object(scope, event, &parsed.event_type, false, false);+ events::initialize_event_object(+ scope,+ event,+ &parsed.event_type,+ parsed.init.bubbles,+ parsed.init.cancelable,+ );+ events::define_event_property(+ scope,+ event,+ "composed",+ v8::Boolean::new(scope, parsed.init.composed).into(),+ );IdbVersionChangeEventFieldsDeclaration::new(parsed.init.old_version,version_change_nullable_version_value(scope, parsed.init.new_version),diff --git a/moli-renderer-v8/src/context_bootstrap/indexed_db/install/constructors.rs b/moli-renderer-v8/src/context_bootstrap/indexed_db/install/constructors.rsindex fa077153e..13f45a7a2 100644--- a/moli-renderer-v8/src/context_bootstrap/indexed_db/install/constructors.rs+++ b/moli-renderer-v8/src/context_bootstrap/indexed_db/install/constructors.rs@@ -11,6 +11,11 @@ pub(in crate::context_bootstrap) fn install_indexed_db_template_bindings<'s>(interface_name: &str,) {let prototype = template.prototype_template(scope);+ super::super::event_target::install_version_change_event_template_bindings(+ scope,+ prototype,+ interface_name,+ );install_dom_string_list_template_bindings(scope, prototype, interface_name);factory_request::install_factory_and_request_template_bindings(scope,