Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
perf(forms): resolve named items from indexed candidates
ldm0c12e9f84164e
diff --git a/moli-dom/src/native/host/clone.rs b/moli-dom/src/native/host/clone.rsindex f21c7c7d7..49ea83dcf 100644--- a/moli-dom/src/native/host/clone.rs+++ b/moli-dom/src/native/host/clone.rs@@ -584,6 +584,9 @@ impl DomHost {let _ = clone_element.set_media_network_state(u32::MAX);let _ = clone_element.set_media_network_state(element.media_network_state());let _ = clone_element.set_media_error_code(element.media_error_code());+ // Cloning copies attributes directly, bypassing set_attribute's index updates.+ // Detached clones must be queryable before any tree insertion refreshes them.+ self.record_named_index_candidate(clone);}}diff --git a/moli-dom/src/native/host/document.rs b/moli-dom/src/native/host/document.rsindex 1e645e7fb..c890e7d32 100644--- a/moli-dom/src/native/host/document.rs+++ b/moli-dom/src/native/host/document.rs@@ -506,6 +506,50 @@ impl DomHost {}}+ /// Compare nodes in the order of a traversal that visits shadow children+ /// before light children. Ordinary document-position comparison treats+ /// different shadow trees as disconnected and cannot order these queries.+ pub fn compare_handles_in_shadow_including_tree_order(+ &self,+ left: DomHandle,+ right: DomHandle,+ ) -> std::cmp::Ordering {+ let ancestors = |handle| {+ let mut path = Vec::new();+ let mut current = Some(handle);+ while let Some(handle) = current {+ path.push(handle);+ current = self+ .parent_node(handle)+ .or_else(|| self.shadow_root_host(handle));+ }+ path.reverse();+ path+ };+ let left_path = ancestors(left);+ let right_path = ancestors(right);+ let common = left_path+ .iter()+ .zip(&right_path)+ .take_while(|(a, b)| a == b)+ .count();+ if common == 0 {+ return left.index().cmp(&right.index());+ }+ match (left_path.get(common), right_path.get(common)) {+ (Some(left), Some(right)) => {+ if self.is_shadow_root(*left) {+ std::cmp::Ordering::Less+ } else if self.is_shadow_root(*right) {+ std::cmp::Ordering::Greater+ } else {+ self.compare_handles_in_document_order(*left, *right)+ }+ }+ _ => left_path.len().cmp(&right_path.len()),+ }+ }+pub fn is_connected(&self, handle: DomHandle) -> bool {self.node(handle).is_some_and(|node| node.flags().connected())@@ -824,22 +868,60 @@ impl DomHost {/// rather than caching misses (custom-element upgrades can change eligibility/// without changing an element's id or name).pub fn has_element_with_named_item_key(&self, key: &str) -> bool {+ self.visit_element_candidates_by_id_or_name(key, |handle| {+ if self+ .node(handle)+ .and_then(Node::as_element)+ .is_some_and(|element| element.matches_named_item_key(key))+ {+ std::ops::ControlFlow::Break(())+ } else {+ std::ops::ControlFlow::Continue(())+ }+ })+ .is_break()+ }++ /// Visit current id/name candidates once each, without restricting document,+ /// connectivity, or tree scope. Callers supply their eligibility rules and+ /// sort accepted nodes if needed. Breaking avoids building a result list or+ /// inspecting the remaining candidates for existence-only queries.+ pub fn visit_element_candidates_by_id_or_name<B>(+ &self,+ key: &str,+ mut visit: impl FnMut(DomHandle) -> std::ops::ControlFlow<B>,+ ) -> std::ops::ControlFlow<B> {if key.is_empty() {- return false;+ return std::ops::ControlFlow::Continue(());}self.ensure_id_index();self.ensure_name_index();- let matches = |index: &NamedElementIndex| {- index.handles_by_value.get(key).is_some_and(|handles| {- handles.iter().any(|handle| {- self.node(*handle)- .and_then(Node::as_element)- .is_some_and(|element| element.matches_named_item_key(key))+ let ids = self.id_index.borrow();+ let names = self.name_index.borrow();+ let ids = ids+ .as_ref()+ .and_then(|index| index.handles_by_value.get(key));+ let names = names+ .as_ref()+ .and_then(|index| index.handles_by_value.get(key));+ let candidates = ids.into_iter().flat_map(NamedElementHandles::iter).chain(+ names+ .into_iter()+ .flat_map(NamedElementHandles::iter)+ .filter(|handle| ids.is_none_or(|ids| !ids.contains(handle))),+ );+ for &handle in candidates {+ if self+ .node(handle)+ .and_then(Node::as_element)+ .is_some_and(|element| {+ element.id() == Some(key) || element.name_attribute() == Some(key)})- })- };- self.id_index.borrow().as_ref().is_some_and(matches)- || self.name_index.borrow().as_ref().is_some_and(matches)+ {+ visit(handle)?;+ }+ }+ std::ops::ControlFlow::Continue(())}pub fn element_handles_by_id_or_name_matching(@@ -847,41 +929,21 @@ impl DomHost {key: &str,mut accepts_name: impl FnMut(DomHandle) -> bool,) -> Vec<DomHandle> {- self.ensure_id_index();- self.ensure_name_index();-- let mut candidates = IndexSet::new();- if let Some(handles) = self- .id_index- .borrow()- .as_ref()- .and_then(|index| index.handles_by_value.get(key))- {- candidates.extend(handles.iter().copied());- }- if let Some(handles) = self- .name_index- .borrow()- .as_ref()- .and_then(|index| index.handles_by_value.get(key))- {- candidates.extend(handles.iter().copied());- }-let document_handle = self.document_handle();- let mut matches = candidates- .into_iter()- .filter(|handle| {- self.node(*handle).is_some_and(|node| {- node.flags().in_document_tree()- && node.owner_document() == Some(document_handle)- && node.as_element().is_some_and(|element| {- element.id() == Some(key)- || (element.name_attribute() == Some(key) && accepts_name(*handle))- })- })- })- .collect::<Vec<_>>();+ let mut matches = Vec::new();+ let _ = self.visit_element_candidates_by_id_or_name(key, |handle| {+ if self.node(handle).is_some_and(|node| {+ node.flags().in_document_tree()+ && node.owner_document() == Some(document_handle)+ && node.as_element().is_some_and(|element| {+ element.id() == Some(key)+ || (element.name_attribute() == Some(key) && accepts_name(handle))+ })+ }) {+ matches.push(handle);+ }+ std::ops::ControlFlow::<()>::Continue(())+ });matches.sort_by(|left, right| self.compare_handles_in_document_order(*left, *right));matches}diff --git a/moli-dom/src/native/host/query_index.rs b/moli-dom/src/native/host/query_index.rsindex a3ba184c4..64eaf76c1 100644--- a/moli-dom/src/native/host/query_index.rs+++ b/moli-dom/src/native/host/query_index.rs@@ -541,6 +541,79 @@ mod tests {assert!(!host.has_element_with_named_item_key(""));}+ #[test]+ fn named_candidate_visits_are_unscoped_deduplicated_and_short_circuitable() {+ use std::ops::ControlFlow;+ let mut host = test_host();+ assert!(!host.has_element_with_named_item_key("shared"));+ let detached = host.create_element("input");+ let shadow_host = host.create_element("div");+ let shadow = host.attach_shadow_root(shadow_host, "open").unwrap();+ let shadow_input = host.create_element("input");+ assert!(host.append_child(shadow, shadow_input));+ let other_document = host.create_detached_html_document();+ let other_input = host.create_element("input");+ assert!(host.append_child(other_document, other_input));+ for handle in [detached, shadow_input, other_input] {+ assert!(host.set_attribute(handle, "id", "shared"));+ assert!(host.set_attribute(handle, "name", "shared"));+ }+ let mut found = Vec::new();+ let result = host.visit_element_candidates_by_id_or_name("shared", |handle| {+ found.push(handle);+ ControlFlow::<()>::Continue(())+ });+ assert!(result.is_continue());+ assert_eq!(found.len(), 3);+ for handle in [detached, shadow_input, other_input] {+ assert!(found.contains(&handle));+ }+ let mut visits = 0;+ let first = host.visit_element_candidates_by_id_or_name("shared", |handle| {+ visits += 1;+ ControlFlow::Break(handle)+ });+ assert!(first.is_break());+ assert_eq!(visits, 1);+ assert!(host.set_attribute(detached, "id", "renamed"));+ assert!(host.remove_attribute(detached, "name"));+ let _ = host.visit_element_candidates_by_id_or_name("shared", |handle| {+ assert_ne!(handle, detached);+ ControlFlow::<()>::Continue(())+ });+ assert_eq!(+ host.visit_element_candidates_by_id_or_name("renamed", ControlFlow::Break),+ ControlFlow::Break(detached)+ );+ assert!(+ host.element_handles_by_id_or_name_matching("shared", |_| true)+ .is_empty()+ );+ }++ #[test]+ fn named_candidates_track_detached_clones_and_imports_after_materialization() {+ use std::ops::ControlFlow;+ let mut host = test_host();+ let source = host.create_element("input");+ assert!(host.set_attribute(source, "id", "cloned"));+ assert!(host.set_attribute(source, "name", "cloned"));+ assert!(host.has_element_with_named_item_key("cloned"));+ let clone = host.clone_node(source, false).unwrap();+ let document = host.create_detached_html_document();+ let imported = host.import_node(document, source, false).unwrap();+ let foreign = host.snapshot_document();+ let foreign_import = host+ .import_foreign_node(document, &foreign, source, false)+ .unwrap();+ let mut candidates = Vec::new();+ let _ = host.visit_element_candidates_by_id_or_name("cloned", |handle| {+ candidates.push(handle);+ ControlFlow::<()>::Continue(())+ });+ assert_eq!(candidates, vec![source, clone, imported, foreign_import]);+ }+#[test]fn cached_tag_name_collection_reuses_query_until_mutation() {let mut host = test_host();diff --git a/moli-dom/src/native/host/types.rs b/moli-dom/src/native/host/types.rsindex da7d2f1bb..c3ec35cc1 100644--- a/moli-dom/src/native/host/types.rs+++ b/moli-dom/src/native/host/types.rs@@ -81,6 +81,13 @@ pub(super) enum NamedElementHandles {}impl NamedElementHandles {+ pub(super) fn contains(&self, handle: &DomHandle) -> bool {+ match self {+ Self::One(current) => current == handle,+ Self::Many(handles) => handles.contains(handle),+ }+ }+pub(super) fn insert(&mut self, handle: DomHandle) {match self {Self::One(current) if *current == handle => {}diff --git a/moli-renderer-v8/src/native_bridge/element.rs b/moli-renderer-v8/src/native_bridge/element.rsindex dee039cb7..a515eb59b 100644--- a/moli-renderer-v8/src/native_bridge/element.rs+++ b/moli-renderer-v8/src/native_bridge/element.rs@@ -35,29 +35,48 @@ mod events;mod focus;mod forms;+#[cfg(test)]+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]+pub(crate) struct FormLookupWork {+ pub traversals: u64,+ pub enumerations: u64,+ pub inspected_nodes: u64,+}+#[cfg(test)]std::thread_local! {- static FORM_LOOKUP_WORK: std::cell::Cell<(u64, u64)> = const { std::cell::Cell::new((0, 0)) };+ static FORM_LOOKUP_WORK: std::cell::Cell<FormLookupWork> = const { std::cell::Cell::new(FormLookupWork { traversals: 0, enumerations: 0, inspected_nodes: 0 }) };}#[cfg(test)]-pub(crate) fn take_form_lookup_work_for_test() -> (u64, u64) {- FORM_LOOKUP_WORK.with(|work| work.replace((0, 0)))+pub(crate) fn take_form_lookup_work_for_test() -> FormLookupWork {+ FORM_LOOKUP_WORK.with(|work| work.replace(FormLookupWork::default()))}#[cfg(test)]fn record_form_lookup_traversal_for_test() {FORM_LOOKUP_WORK.with(|work| {- let (traversals, enumerations) = work.get();- work.set((traversals + 1, enumerations));+ let mut current = work.get();+ current.traversals += 1;+ work.set(current);});}#[cfg(test)]fn record_form_lookup_enumeration_for_test() {FORM_LOOKUP_WORK.with(|work| {- let (traversals, enumerations) = work.get();- work.set((traversals, enumerations + 1));+ let mut current = work.get();+ current.enumerations += 1;+ work.set(current);+ });+}++#[cfg(test)]+fn record_form_lookup_node_for_test() {+ FORM_LOOKUP_WORK.with(|work| {+ let mut current = work.get();+ current.inspected_nodes += 1;+ work.set(current);});}mod geometry;diff --git a/moli-renderer-v8/src/native_bridge/element/forms/form_element.rs b/moli-renderer-v8/src/native_bridge/element/forms/form_element.rsindex 5c28ea517..792d300df 100644--- a/moli-renderer-v8/src/native_bridge/element/forms/form_element.rs+++ b/moli-renderer-v8/src/native_bridge/element/forms/form_element.rs@@ -3,6 +3,7 @@ use crate::custom_elements::is_form_associated_custom_element_handle;use crate::native_bridge::bridge::wrapped_handle_value_for_receiver;use crate::native_bridge::element::{html_element_getter_receiver, html_element_setter_receiver};use moli_webapi_declare::DataPropertyDescriptorDeclaration;+use std::ops::ControlFlow;pub(in crate::native_bridge) fn form_action_getter_function<'s>(scope: &mut v8::PinScope<'s, '_>,@@ -272,35 +273,55 @@ pub(crate) fn form_control_elements(runtime: &JsContextHost,form_handle: DomHandle,) -> Vec<DomHandle> {- if runtime- .dom_host()- .is_html_element_named(form_handle, "fieldset")- {- return collect_form_control_elements_from(runtime, form_handle, false, None, false);- }-- if !runtime- .dom_host()- .is_html_element_named(form_handle, "form")- {+ let Some(scope) = FormControlScope::new(runtime, form_handle) else {return Vec::new();- }+ };+ collect_form_control_elements_from(runtime, scope.root, false, scope.owner, false)+}- if !runtime.dom_host().is_connected(form_handle) {- return collect_form_control_elements_from(- runtime,- form_handle,- false,- Some(form_handle),- false,- );+#[derive(Clone, Copy)]+struct FormControlScope {+ root: DomHandle,+ owner: Option<DomHandle>,+}++impl FormControlScope {+ fn new(runtime: &JsContextHost, form: DomHandle) -> Option<Self> {+ let dom = runtime.dom_host();+ if dom.is_html_element_named(form, "fieldset") {+ return Some(Self {+ root: form,+ owner: None,+ });+ }+ if !dom.is_html_element_named(form, "form") {+ return None;+ }+ let root = if dom.is_connected(form) {+ dom.owner_document_handle(form)+ .unwrap_or_else(|| dom.document_handle())+ } else {+ form+ };+ Some(Self {+ root,+ owner: Some(form),+ })}- let document_handle = runtime- .dom_host()- .owner_document_handle(form_handle)- .unwrap_or_else(|| runtime.dom_host().document_handle());- collect_form_control_elements_from(runtime, document_handle, false, Some(form_handle), false)+ fn contains(self, runtime: &JsContextHost, candidate: DomHandle) -> bool {+ let dom = runtime.dom_host();+ let mut current = dom.parent_node(candidate);+ while let Some(handle) = current {+ if handle == self.root {+ return true;+ }+ current = dom+ .parent_node(handle)+ .or_else(|| dom.shadow_root_host(handle));+ }+ false+ }}pub(crate) fn form_data_control_elements(@@ -367,10 +388,9 @@ fn collect_form_control_elements_from(push_shadow_including_children(runtime, root, &mut stack);}while let Some(handle) = stack.pop() {- if is_form_control_handle(runtime, handle, include_image_inputs)- && form_handle- .is_none_or(|owner| form_associated_form_owner(runtime, handle) == Some(owner))- {+ #[cfg(test)]+ crate::native_bridge::element::record_form_lookup_node_for_test();+ if form_control_matches_owner(runtime, handle, form_handle, include_image_inputs) {out.push(handle);}push_shadow_including_children(runtime, handle, &mut stack);@@ -425,6 +445,16 @@ fn is_form_control_handle(})}+fn form_control_matches_owner(+ runtime: &JsContextHost,+ handle: DomHandle,+ owner: Option<DomHandle>,+ include_image_inputs: bool,+) -> bool {+ is_form_control_handle(runtime, handle, include_image_inputs)+ && owner.is_none_or(|owner| form_associated_form_owner(runtime, handle) == Some(owner))+}+pub(in crate::native_bridge) fn fieldset_elements_getter_function<'s>(scope: &mut v8::PinScope<'s, '_>,args: v8::FunctionCallbackArguments<'s>,@@ -745,9 +775,19 @@ fn form_has_named_item_or_past_name(form_handle: DomHandle,key: &str,) -> bool {- !form_named_item_matches(runtime, form_handle, key)- .1- .is_empty()+ let Some(scope) = FormControlScope::new(runtime, form_handle) else {+ return false;+ };+ runtime+ .dom_host()+ .visit_element_candidates_by_id_or_name(key, |candidate| {+ if form_named_candidate_source(runtime, scope, candidate, key).is_some() {+ ControlFlow::Break(())+ } else {+ ControlFlow::Continue(())+ }+ })+ .is_break()|| runtime.form_past_named_item(form_handle, key).is_some()}@@ -945,21 +985,27 @@ fn form_named_item_matches(form_handle: DomHandle,key: &str,) -> (LiveCollectionQueryKind, Vec<DomHandle>) {- // Only a miss is conclusive. A hit still needs the existing form-owner,- // custom-element, shadow-tree and image-fallback rules below. The caller- // separately checks the past-names map even when this returns no matches.- if !runtime.dom_host().has_element_with_named_item_key(key) {+ let Some(scope) = FormControlScope::new(runtime, form_handle) else {return (LiveCollectionQueryKind::FormControlsByName, Vec::new());- }- let controls = form_named_control_matches(runtime, form_handle, key);- if controls.is_empty() {- (- LiveCollectionQueryKind::FormImagesByName,- form_named_image_matches(runtime, form_handle, key),- )- } else {- (LiveCollectionQueryKind::FormControlsByName, controls)- }+ };+ let mut query_kind = LiveCollectionQueryKind::FormImagesByName;+ let mut matches = Vec::new();+ let _ = runtime+ .dom_host()+ .visit_element_candidates_by_id_or_name(key, |candidate| {+ if let Some(source) = form_named_candidate_source(runtime, scope, candidate, key) {+ if source == LiveCollectionQueryKind::FormControlsByName && source != query_kind {+ query_kind = source;+ matches.clear();+ }+ if source == query_kind {+ matches.push(candidate);+ }+ }+ ControlFlow::<()>::Continue(())+ });+ sort_form_named_matches(runtime, &mut matches);+ (query_kind, matches)}pub(in crate::native_bridge) fn form_named_control_matches(@@ -967,16 +1013,12 @@ pub(in crate::native_bridge) fn form_named_control_matches(form_handle: DomHandle,key: &str,) -> Vec<DomHandle> {- form_control_elements(runtime, form_handle)- .into_iter()- .filter(|handle| {- runtime- .dom_host()- .node(*handle)- .and_then(Node::as_element)- .is_some_and(|element| element.matches_named_item_key(key))- })- .collect()+ form_named_matches_from_source(+ runtime,+ form_handle,+ key,+ LiveCollectionQueryKind::FormControlsByName,+ )}pub(in crate::native_bridge) fn form_named_image_matches(@@ -984,25 +1026,71 @@ pub(in crate::native_bridge) fn form_named_image_matches(form_handle: DomHandle,key: &str,) -> Vec<DomHandle> {- if !runtime+ form_named_matches_from_source(+ runtime,+ form_handle,+ key,+ LiveCollectionQueryKind::FormImagesByName,+ )+}++fn form_named_matches_from_source(+ runtime: &JsContextHost,+ form_handle: DomHandle,+ key: &str,+ source: LiveCollectionQueryKind,+) -> Vec<DomHandle> {+ let Some(scope) = FormControlScope::new(runtime, form_handle) else {+ return Vec::new();+ };+ let mut matches = Vec::new();+ let _ = runtime.dom_host()- .is_html_element_named(form_handle, "form")+ .visit_element_candidates_by_id_or_name(key, |candidate| {+ if form_named_candidate_source(runtime, scope, candidate, key) == Some(source) {+ matches.push(candidate);+ }+ ControlFlow::<()>::Continue(())+ });+ sort_form_named_matches(runtime, &mut matches);+ matches+}++fn form_named_candidate_source(+ runtime: &JsContextHost,+ scope: FormControlScope,+ candidate: DomHandle,+ key: &str,+) -> Option<LiveCollectionQueryKind> {+ #[cfg(test)]+ crate::native_bridge::element::record_form_lookup_node_for_test();+ let element = runtime+ .dom_host()+ .node(candidate)+ .and_then(Node::as_element)?;+ if !element.matches_named_item_key(key) {+ return None;+ }+ if form_control_matches_owner(runtime, candidate, scope.owner, false)+ && scope.contains(runtime, candidate){- return Vec::new();+ Some(LiveCollectionQueryKind::FormControlsByName)+ } else if element.is_html_element("img")+ && scope.owner.is_some()+ && nearest_form_ancestor(runtime, candidate) == scope.owner+ {+ Some(LiveCollectionQueryKind::FormImagesByName)+ } else {+ None}- runtime- .dom_host()- .elements_by_tag_name(form_handle, "img", false)- .into_iter()- .filter(|handle| nearest_form_ancestor(runtime, *handle) == Some(form_handle))- .filter(|handle| {- runtime- .dom_host()- .node(*handle)- .and_then(Node::as_element)- .is_some_and(|element| element.matches_named_item_key(key))- })- .collect()+}++fn sort_form_named_matches(runtime: &JsContextHost, matches: &mut [DomHandle]) {+ matches.sort_by(|left, right| {+ runtime+ .dom_host()+ .compare_handles_in_shadow_including_tree_order(*left, *right)+ });}fn nearest_form_ancestor(runtime: &JsContextHost, handle: DomHandle) -> Option<DomHandle> {diff --git a/moli-renderer-v8/src/script_vm/tests/dom_xhr/forms/named_lookup.rs b/moli-renderer-v8/src/script_vm/tests/dom_xhr/forms/named_lookup.rsindex 3c4d1d4a2..4050c8456 100644--- a/moli-renderer-v8/src/script_vm/tests/dom_xhr/forms/named_lookup.rs+++ b/moli-renderer-v8/src/script_vm/tests/dom_xhr/forms/named_lookup.rs@@ -1,5 +1,151 @@use super::*;+#[test]+fn form_named_lookup_checks_only_index_candidates_and_existence_stops_early() {+ use crate::native_bridge::element::take_form_lookup_work_for_test;+ let mut vm = new_parsed_test_vm(+ "https://form-index-work.test/",+ "<!doctype html><body></body>",+ );+ vm.exec(+ r#"+ globalThis.indexForm = document.body.appendChild(document.createElement('form'));+ globalThis.firstIndexed = indexForm.appendChild(document.createElement('input'));+ firstIndexed.id = firstIndexed.name = 'indexedGroup';+ for (let i = 0; i < 63; ++i) {+ indexForm.appendChild(document.createElement('input')).name = 'indexedGroup';+ }+ globalThis.otherForm = document.body.appendChild(document.createElement('form'));+ otherForm.appendChild(document.createElement('input')).name = 'otherOnly';+ for (let i = 0; i < 512; ++i) {+ const div = document.body.appendChild(document.createElement('div'));+ div.innerHTML = '<span></span><input name="unrelated">';+ }+ indexForm.absentPrimeKey;+ "#,+ None,+ )+ .unwrap();+ take_form_lookup_work_for_test();+ assert_eq!(vm.eval("'indexedGroup' in indexForm").unwrap(), "true");+ let work = take_form_lookup_work_for_test();+ assert_eq!(work.inspected_nodes, 1);+ assert_eq!((work.traversals, work.enumerations), (0, 0));+ assert_eq!(+ vm.eval("indexForm.otherOnly === undefined").unwrap(),+ "true"+ );+ let work = take_form_lookup_work_for_test();+ assert_eq!(work.inspected_nodes, 1);+ assert_eq!((work.traversals, work.enumerations), (0, 0));+ assert_eq!(+ vm.eval("globalThis.indexedList = indexForm.indexedGroup; true")+ .unwrap(),+ "true"+ );+ let work = take_form_lookup_work_for_test();+ assert_eq!(+ work.inspected_nodes, 64,+ "id/name duplicates must be inspected once"+ );+ assert_eq!((work.traversals, work.enumerations), (0, 0));+ assert_eq!(vm.eval("indexedList.length").unwrap(), "64");+ let work = take_form_lookup_work_for_test();+ assert_eq!(+ work.inspected_nodes, 64,+ "live list evaluation must also use candidates"+ );+ assert_eq!(work.traversals, 0);+}++#[test]+fn form_named_lookup_existence_does_not_remember_past_names() {+ let mut vm = new_parsed_test_vm(+ "https://form-index-existence.test/",+ "<!doctype html><body></body>",+ );+ assert_eq!(vm.eval(r#"(() => {+ const form = document.body.appendChild(document.createElement('form'));+ for (const tag of ['input', 'img']) {+ const item = form.appendChild(document.createElement(tag));+ item.name = 'existenceOnly';+ if (!('existenceOnly' in form)) throw Error('missing supported name');+ item.name = 'renamed';+ if ('existenceOnly' in form || form.existenceOnly !== undefined) throw Error('query remembered past name');+ item.remove();+ }+ return 'ok';+ })()"#).unwrap(), "ok");+}++#[test]+fn form_named_lookup_index_survives_parsing_import_and_control_type_changes() {+ let mut vm = new_parsed_test_vm(+ "https://form-index-import.test/",+ "<!doctype html><body></body>",+ );+ assert_eq!(vm.eval(r#"(() => {+ const empty = document.body.appendChild(document.createElement('form'));+ empty.primeIndexes;+ const parsed = new DOMParser().parseFromString('<form><input name="shared"><input id="shared" name="shared"><img name="shared"><img name="shared"></form>', 'text/html');+ const original = parsed.querySelector('form');+ const imported = document.importNode(original, true);+ for (const [mode, form] of [original, imported].entries()) {+ const inputs = form.querySelectorAll('input');+ const list = form.shared;+ if (!list) throw Error(mode + ': missing list: ' + form.outerHTML + '; elements=' + form.elements.length);+ if (list.length !== 2 || list[0] !== inputs[0] || list[1] !== inputs[1]) throw Error('parsed/imported candidates');+ form.insertBefore(inputs[1], inputs[0]);+ if (list[0] !== inputs[1]) throw Error('candidate insertion order leaked');+ inputs[1].type = 'image';+ if (list.length !== 1 || form.shared !== inputs[0]) throw Error('type eligibility');+ inputs[0].type = 'image';+ if (list.length !== 0 || form.shared.length !== 2 || form.shared[0].tagName !== 'IMG') throw Error('image fallback');+ document.body.appendChild(document.adoptNode(form));+ inputs[1].type = 'text';+ if (list.length !== 1 || list[0] !== inputs[1] || form.shared !== inputs[1]) throw Error('adoption and type restoration');+ }+ return 'ok';+ })()"#).unwrap(), "ok");+}++#[test]+fn form_named_lookup_orders_shadow_reference_controls_and_filters_fieldset_scope() {+ let mut vm = new_parsed_test_vm(+ "https://form-index-shadow.test/",+ "<!doctype html><body></body>",+ );+ assert_eq!(vm.eval(r#"(() => {+ const host = document.body.appendChild(document.createElement('div'));+ host.id = 'formHost';+ const root = host.attachShadow({mode: 'open', referenceTarget: 'form'});+ root.innerHTML = '<form id="form"><input name="shared"><input name="shared"></form>';+ const form = root.querySelector('form');+ const inside = form.querySelectorAll('input');+ const external = host.appendChild(document.createElement('input'));+ external.setAttribute('form', 'formHost');+ external.name = 'shared';+ const before = document.body.insertBefore(document.createElement('input'), host);+ before.setAttribute('form', 'formHost');+ before.name = 'shared';+ const list = form.shared;+ function check(expected) {+ if (list.length !== expected.length || expected.some((item, i) => list[i] !== item)) throw Error('shadow-including order');+ }+ check([before, inside[0], inside[1], external]);+ document.body.appendChild(before);+ check([inside[0], inside[1], external, before]);+ host.remove();+ check([inside[0], inside[1]]);+ const fieldset = document.body.appendChild(document.createElement('fieldset'));+ fieldset.innerHTML = '<input name="shared"><form><input name="shared"></form>';+ const fieldsetInputs = fieldset.querySelectorAll('input');+ const fieldsetList = fieldset.elements;+ if (fieldsetList.length !== 2 || fieldsetList[1] !== fieldsetInputs[1] || fieldsetList.namedItem('shared') !== fieldsetInputs[0]) throw Error('fieldset candidate scope');+ return 'ok';+ })()"#).unwrap(), "ok");+}+#[test]fn form_named_lookup_own_properties_take_precedence_over_controls_and_prototypes() {let mut vm = new_parsed_test_vm(@@ -208,18 +354,21 @@ fn form_named_lookup_misses_do_not_enumerate_or_traverse_controls() {assert_eq!(result, "ok");assert_eq!(crate::native_bridge::element::take_form_lookup_work_for_test(),- (0, 0)+ Default::default());// Positive control: the counter must observe real supported-property work.assert_eq!(vm.eval("lookupForms[0].present.tagName").unwrap(), "INPUT");- let (traversals, enumerations) =- crate::native_bridge::element::take_form_lookup_work_for_test();- assert!(traversals > 0);- assert_eq!(enumerations, 0);+ let work = crate::native_bridge::element::take_form_lookup_work_for_test();+ assert!(work.inspected_nodes > 0);+ assert_eq!(work.traversals, 0);+ assert_eq!(work.enumerations, 0);vm.eval("Object.getOwnPropertyNames(lookupForms[0]).length").unwrap();- assert!(crate::native_bridge::element::take_form_lookup_work_for_test().1 > 0);+ let work = crate::native_bridge::element::take_form_lookup_work_for_test();+ assert!(work.enumerations > 0);+ assert!(work.traversals > 0);+ assert!(work.inspected_nodes > 0);}#[test]