Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
refactor(renderer): make parser finish boundaries explicit
ldm03d6f263e283e
diff --git a/moli-renderer-v8/src/document_runtime.rs b/moli-renderer-v8/src/document_runtime.rsindex e789e7cd0..0d1957ed8 100644--- a/moli-renderer-v8/src/document_runtime.rs+++ b/moli-renderer-v8/src/document_runtime.rs@@ -1,6 +1,7 @@use std::{cell::RefCell,collections::{HashMap, HashSet, VecDeque},+ rc::Weak,sync::Arc,};@@ -110,6 +111,7 @@ pub(crate) use stylesheet_runtime::{pub(super) type DomHandle = NativeNodeId;pub(crate) type ParserStreamHandle = crate::live_document_parser::DocumentParserStreamHandle;+type ParserStreamWeakHandle = Weak<RefCell<crate::parser::DocumentStream>>;#[derive(Debug, Clone, Copy, PartialEq, Eq)]pub(crate) enum HtmlFragmentCustomElementUpgradeTiming {@@ -169,7 +171,7 @@ pub(crate) enum PostParseOwnerDriverStep {#[derive(Debug)]struct ParserConnectedScriptContext {- insertion_controller: ParserInsertionController,+ bridge: ParserConnectedScriptBridge,_input_context: ParserInputContext,}@@ -183,53 +185,121 @@ struct CurrentScriptContext {pub(crate) struct CurrentScriptContextSpec {pub(crate) handle: Option<DomHandle>,pub(crate) parser_write_insertion_point_active: bool,- pub(crate) parser_insertion_controller: Option<ParserInsertionController>,+ pub(crate) parser_bridge: Option<ParserConnectedScriptBridge>,}#[derive(Clone)]pub(crate) struct ParserInsertionController {input_session: ParserInputSession,- parser_stream: ParserStreamHandle,- parser_control: DocumentParserSessionControlHandle,+ parser_stream: ParserStreamWeakHandle,}impl std::fmt::Debug for ParserInsertionController {fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {f.debug_struct("ParserInsertionController").field("input_session", &self.input_session)- .field("session_id", &self.parser_control.session_id())- .field("run_state", &self.parser_control.run_state()).finish()}}impl ParserInsertionController {- #[cfg(test)]- pub(crate) fn for_stream(stream: ParserStreamHandle) -> Self {+ fn for_stream(stream: &ParserStreamHandle) -> Self {let input_session = stream.borrow().script_input_session();Self {input_session,- parser_stream: stream,+ parser_stream: std::rc::Rc::downgrade(stream),+ }+ }++ pub(crate) fn input_session(&self) -> ParserInputSession {+ self.input_session.clone()+ }++ pub(crate) fn with_parser_stream<R>(+ &self,+ operation: impl FnOnce(&crate::parser::DocumentStream) -> R,+ ) -> R {+ let stream = self+ .parser_stream+ .upgrade()+ .expect("synchronous parser insertion permission outlived its parser session");+ let stream = stream.borrow();+ operation(&stream)+ }++ pub(crate) fn with_parser_stream_mut<R>(+ &self,+ operation: impl FnOnce(&mut crate::parser::DocumentStream) -> R,+ ) -> R {+ let stream = self+ .parser_stream+ .upgrade()+ .expect("synchronous parser insertion permission outlived its parser session");+ let mut stream = stream.borrow_mut();+ operation(&mut stream)+ }+}++/// The explicit bridge between parser-connected script execution and the+/// phase-owned parser session.+///+/// The insertion controller is deliberately limited to synchronous input+/// insertion. Pump/suspend/script-nesting transitions are reported through+/// the separate session control handle so retaining insertion permission can+/// never itself authorize parser finalization.+#[derive(Clone)]+pub(crate) struct ParserConnectedScriptBridge {+ insertion_controller: ParserInsertionController,+ parser_control: DocumentParserSessionControlHandle,+}++impl std::fmt::Debug for ParserConnectedScriptBridge {+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ f.debug_struct("ParserConnectedScriptBridge")+ .field("insertion_controller", &self.insertion_controller)+ .field("session_id", &self.parser_control.session_id())+ .field("run_state", &self.parser_control.run_state())+ .field(+ "pump_session_nesting_level",+ &self.parser_control.pump_session_nesting_level(),+ )+ .field(+ "parser_script_nesting_level",+ &self.parser_control.parser_script_nesting_level(),+ )+ .field(+ "finish_request_state",+ &self.parser_control.finish_request_state(),+ )+ .finish()+ }+}++impl ParserConnectedScriptBridge {+ #[cfg(test)]+ pub(crate) fn for_stream(stream: &ParserStreamHandle) -> Self {+ Self {+ insertion_controller: ParserInsertionController::for_stream(stream),parser_control: DocumentParserSessionControlHandle::new(),}}pub(crate) fn for_session(parser: &DocumentParserSession) -> Option<Self> {- let parser_stream = parser.html_stream_handle()?;- let input_session = parser_stream.borrow().script_input_session();+ let stream = parser.html_stream_handle()?;Some(Self {- input_session,- parser_stream,+ insertion_controller: ParserInsertionController::for_stream(&stream),parser_control: parser.control_handle(),})}- pub(crate) fn input_session(&self) -> ParserInputSession {- self.input_session.clone()+ pub(crate) fn insertion_controller(&self) -> &ParserInsertionController {+ &self.insertion_controller}- pub(crate) fn parser_stream(&self) -> ParserStreamHandle {- self.parser_stream.clone()+ pub(crate) fn enter_parser_script_nesting(+ &self,+ ) -> crate::live_document_parser::DocumentParserScriptNestingGuard {+ self.parser_control.enter_parser_script_nesting()}pub(crate) fn run_state(&self) -> DocumentParserRunState {@@ -390,7 +460,7 @@ struct DocumentWriteExternalScriptStart {#[derive(Debug)]struct SuspendedDocumentWriteInsertion {document_handle: DomHandle,- parser_insertion_controller: ParserInsertionController,+ parser_bridge: ParserConnectedScriptBridge,resume_permit: ParserResumePermit,resume_permit_consumed: bool,}@@ -548,6 +618,7 @@ struct ParserReentryState {pub(crate) struct ParserScriptNestingGuard {runtime: *mut DocumentRuntime,+ _parser_session: Option<crate::live_document_parser::DocumentParserScriptNestingGuard>,}pub(crate) struct ParserPauseGuard {@@ -835,6 +906,9 @@ impl DocumentRuntime {}pub(crate) fn enter_parser_script_nesting(&mut self) -> ParserScriptNestingGuard {+ let parser_session = self+ .current_parser_bridge()+ .map(|bridge| bridge.enter_parser_script_nesting());self.parser_reentry.script_nesting_level = self.parser_reentry.script_nesting_level@@ -842,6 +916,7 @@ impl DocumentRuntime {.expect("parser script nesting level overflow");ParserScriptNestingGuard {runtime: self as *mut DocumentRuntime,+ _parser_session: parser_session,}}diff --git a/moli-renderer-v8/src/document_runtime/document_write.rs b/moli-renderer-v8/src/document_runtime/document_write.rsindex 76722a8fe..c6356396a 100644--- a/moli-renderer-v8/src/document_runtime/document_write.rs+++ b/moli-renderer-v8/src/document_runtime/document_write.rs@@ -369,10 +369,6 @@ impl DocumentRuntime {.as_ref().is_none_or(|parser| parser.lifetime() != DocumentParserLifetime::Closing)|| self.has_pending_document_write_parser_blocking_work()- || self- .root_document_parser- .as_ref()- .is_some_and(|parser| parser.run_state() != DocumentParserRunState::Ready)|| self.root_document_parser.as_ref()@@ -380,16 +376,17 @@ impl DocumentRuntime {{return false;}- // A speculative script preload can complete before a blocking- // stylesheet. Resuming that stylesheet may then consume the ready- // script synchronously while an outer parser pump still owns this- // stream. EOF is real, but finalization must wait until that recovery- // stack unwinds and the root controller is again the sole owner.- if self+ let parser = self.root_document_parser- .as_ref()- .is_some_and(|parser| !parser.has_exclusive_stream_handle())- {+ .as_mut()+ .expect("closing root parser existence was checked");+ // This is an actual attempt to end, not merely the earlier close/EOF+ // notification. If it overlaps a pump, suspension, or parser script,+ // retain that fact so the next owner boundary must explicitly admit+ // the delayed finish.+ parser.request_finish();+ let _ = parser.admit_delayed_finish_at_local_owner_boundary();+ if !parser.can_finish_now() {return false;}let Some(mut parser) = self.root_document_parser.take() else {@@ -1311,12 +1308,14 @@ impl DocumentRuntime {};pending.insertion- .parser_insertion_controller+ .parser_bridge+ .insertion_controller().input_session().enqueue_script_input_html(html.to_owned());pending.insertion- .parser_insertion_controller+ .parser_bridge+ .insertion_controller().input_session().enqueue_script_input_preload_html(html.to_owned());true@@ -1331,12 +1330,14 @@ impl DocumentRuntime {};pending.insertion- .parser_insertion_controller+ .parser_bridge+ .insertion_controller().input_session().enqueue_script_input_html(html.to_owned());pending.insertion- .parser_insertion_controller+ .parser_bridge+ .insertion_controller().input_session().enqueue_script_input_preload_html(html.to_owned());true@@ -1348,12 +1349,14 @@ impl DocumentRuntime {};pending.insertion- .parser_insertion_controller+ .parser_bridge+ .insertion_controller().input_session().enqueue_script_input_html(html.to_owned());pending.insertion- .parser_insertion_controller+ .parser_bridge+ .insertion_controller().input_session().enqueue_script_input_preload_html(html.to_owned());true@@ -1485,11 +1488,11 @@ impl DocumentRuntime {) -> bool {match continuation {SuspendedDocumentWriteContinuation::ResumeAfterCompleted { start, insertion } => {- let parser_insertion_controller = insertion.parser_insertion_controller.clone();+ let parser_bridge = insertion.parser_bridge.clone();self.set_current_script_context(CurrentScriptContextSpec {handle: Some(start.node),parser_write_insertion_point_active: true,- parser_insertion_controller: Some(parser_insertion_controller),+ parser_bridge: Some(parser_bridge),});let changed =self.resume_suspended_document_write_insertion(scope, host_ptr, insertion);@@ -1545,14 +1548,17 @@ impl DocumentRuntime {tracing::debug!(document_handle = ?insertion.document_handle,permit = ?insertion.resume_permit,- run_state = ?insertion.parser_insertion_controller.run_state(),+ run_state = ?insertion.parser_bridge.run_state(),"dropping stale document.write parser continuation");return false;}let mut changed = false;- let parser_input_session = insertion.parser_insertion_controller.input_session();+ let parser_input_session = insertion+ .parser_bridge+ .insertion_controller()+ .input_session();while let Some(script_input_html) = parser_input_session.take_next_script_input_html() {if self.write_html_via_parser_stream(scope,@@ -1560,7 +1566,7 @@ impl DocumentRuntime {insertion.document_handle,&script_input_html,false,- &insertion.parser_insertion_controller,+ &insertion.parser_bridge,) {changed = true;}@@ -1581,7 +1587,7 @@ impl DocumentRuntime {insertion.document_handle,"",true,- &insertion.parser_insertion_controller,+ &insertion.parser_bridge,) {changed = true;}@@ -1589,10 +1595,9 @@ impl DocumentRuntime {return true;}if !insertion- .parser_insertion_controller- .parser_stream()- .borrow()- .has_pending_input()+ .parser_bridge+ .insertion_controller()+ .with_parser_stream(DocumentStream::has_pending_input){break;}@@ -1605,14 +1610,13 @@ impl DocumentRuntime {insertion: &mut SuspendedDocumentWriteInsertion,) -> bool {if insertion.resume_permit_consumed {- return insertion.parser_insertion_controller.run_state()- == DocumentParserRunState::Ready;+ return insertion.parser_bridge.run_state() == DocumentParserRunState::Ready;}- let resumed = match insertion.parser_insertion_controller.run_state() {+ let resumed = match insertion.parser_bridge.run_state() {DocumentParserRunState::Ready => false,- DocumentParserRunState::Suspended { .. } => insertion- .parser_insertion_controller- .resume(insertion.resume_permit),+ DocumentParserRunState::Suspended { .. } => {+ insertion.parser_bridge.resume(insertion.resume_permit)+ }DocumentParserRunState::Pumping { .. }| DocumentParserRunState::Finishing| DocumentParserRunState::Finished@@ -1628,7 +1632,7 @@ impl DocumentRuntime {insertion: &mut SuspendedDocumentWriteInsertion,cause: ParserSuspensionCause,) {- insertion.resume_permit = insertion.parser_insertion_controller.suspend(cause);+ insertion.resume_permit = insertion.parser_bridge.suspend(cause);insertion.resume_permit_consumed = false;}@@ -1731,7 +1735,7 @@ impl DocumentRuntime {tracing::debug!(target = ?completion_target,permit = ?insertion.resume_permit,- run_state = ?insertion.parser_insertion_controller.run_state(),+ run_state = ?insertion.parser_bridge.run_state(),"rejecting document.write external-script terminal for a stale parser suspension");return super::DocumentWriteExternalScriptLoadApplication::RejectedStaleTarget;@@ -1778,7 +1782,7 @@ impl DocumentRuntime {start.node,&start.host_script_handle,source,- Some(insertion.parser_insertion_controller.clone()),+ Some(insertion.parser_bridge.clone()),DocumentWriteCurrentScriptEventBehavior::DispatchImmediately(ScriptEventKind::Load,),@@ -1872,13 +1876,13 @@ impl DocumentRuntime {fn take_suspended_document_write_insertion(&mut self,document_handle: DomHandle,- parser_insertion_controller: &ParserInsertionController,+ parser_bridge: &ParserConnectedScriptBridge,cause: ParserSuspensionCause,) -> SuspendedDocumentWriteInsertion {SuspendedDocumentWriteInsertion {document_handle,- parser_insertion_controller: parser_insertion_controller.clone(),- resume_permit: parser_insertion_controller.suspend(cause),+ parser_bridge: parser_bridge.clone(),+ resume_permit: parser_bridge.suspend(cause),resume_permit_consumed: false,}}@@ -1886,7 +1890,7 @@ impl DocumentRuntime {fn suspend_document_write_stylesheet_blocked_script(&mut self,document_handle: DomHandle,- parser_insertion_controller: &ParserInsertionController,+ parser_bridge: &ParserConnectedScriptBridge,node: DomHandle,start_line: u64,start_column: u64,@@ -1902,7 +1906,7 @@ impl DocumentRuntime {let _ = self.dom_host_mut().set_script_already_started(node, true);let insertion = self.take_suspended_document_write_insertion(document_handle,- parser_insertion_controller,+ parser_bridge,ParserSuspensionCause::ParserClassicStylesheets { script: node },);self.pending_document_write_stylesheet_blocked_script =@@ -1921,7 +1925,7 @@ impl DocumentRuntime {&mut self,host_ptr: *mut JsContextHost,document_handle: DomHandle,- parser_insertion_controller: &ParserInsertionController,+ parser_bridge: &ParserConnectedScriptBridge,stylesheet_owner: DomHandle,blocking_signatures: HashSet<DocumentBlockingStylesheetSignature>,) -> bool {@@ -1932,15 +1936,14 @@ impl DocumentRuntime {);let insertion = self.take_suspended_document_write_insertion(document_handle,- parser_insertion_controller,+ parser_bridge,ParserSuspensionCause::ParserCreatedStylesheet {owner: stylesheet_owner,},);- let preload_html = parser_insertion_controller- .parser_stream()- .borrow()- .snapshot_pending_input();+ let preload_html = parser_bridge+ .insertion_controller()+ .with_parser_stream(DocumentStream::snapshot_pending_input);self.scan_document_write_script_preloads(host_ptr, &preload_html, true);self.pending_document_write_stylesheet_parser_pause =Some(PendingDocumentWriteStylesheetParserPause {@@ -1955,7 +1958,7 @@ impl DocumentRuntime {scope: &mut v8::PinScope<'_, '_>,host_ptr: *mut JsContextHost,document_handle: DomHandle,- parser_insertion_controller: &ParserInsertionController,+ parser_bridge: &ParserConnectedScriptBridge,node: DomHandle,start_line: u64,start_column: u64,@@ -1970,14 +1973,14 @@ impl DocumentRuntime {host_ptr,node,script,- Some(parser_insertion_controller.clone()),+ Some(parser_bridge.clone()),)else {return false;};let insertion = self.take_suspended_document_write_insertion(document_handle,- parser_insertion_controller,+ parser_bridge,ParserSuspensionCause::DocumentWriteExternalScript { script: node },);self.start_document_write_external_script_load(@@ -2051,14 +2054,14 @@ impl DocumentRuntime {host_ptr,node,script,- Some(insertion.parser_insertion_controller.clone()),+ Some(insertion.parser_bridge.clone()),) {DocumentWriteScriptRunOutcome::Complete => {- let parser_insertion_controller = insertion.parser_insertion_controller.clone();+ let parser_bridge = insertion.parser_bridge.clone();self.set_current_script_context(CurrentScriptContextSpec {handle: Some(node),parser_write_insertion_point_active: true,- parser_insertion_controller: Some(parser_insertion_controller),+ parser_bridge: Some(parser_bridge),});let _ = self.resume_suspended_document_write_insertion(scope, host_ptr, insertion);self.clear_current_script_handle();@@ -2087,7 +2090,7 @@ impl DocumentRuntime {scope: &mut v8::PinScope<'_, '_>,host_ptr: *mut JsContextHost,document_handle: DomHandle,- parser_insertion_controller: &ParserInsertionController,+ parser_bridge: &ParserConnectedScriptBridge,node: DomHandle,start_line: u64,start_column: u64,@@ -2100,7 +2103,7 @@ impl DocumentRuntime {host_ptr,node,script,- Some(parser_insertion_controller.clone()),+ Some(parser_bridge.clone()),) {DocumentWriteScriptRunOutcome::Complete => {self.has_pending_document_write_parser_blocking_work()@@ -2110,7 +2113,7 @@ impl DocumentRuntime {scope,host_ptr,document_handle,- parser_insertion_controller,+ parser_bridge,start,),}@@ -2286,13 +2289,13 @@ impl DocumentRuntime {scope: &mut v8::PinScope<'_, '_>,host_ptr: *mut JsContextHost,document_handle: DomHandle,- parser_insertion_controller: &ParserInsertionController,+ parser_bridge: &ParserConnectedScriptBridge,start: Box<DocumentWriteExternalScriptStart>,) -> bool {let script = start.node;let insertion = self.take_suspended_document_write_insertion(document_handle,- parser_insertion_controller,+ parser_bridge,ParserSuspensionCause::DocumentWriteExternalScript { script },);self.start_document_write_external_script_load(@@ -2309,7 +2312,7 @@ impl DocumentRuntime {scope: &mut v8::PinScope<'_, '_>,host_ptr: *mut JsContextHost,document_handle: DomHandle,- parser_insertion_controller: &ParserInsertionController,+ parser_bridge: &ParserConnectedScriptBridge,handoff: ParserScriptHandoff,) -> bool {match handoff {@@ -2328,7 +2331,7 @@ impl DocumentRuntime {scope,host_ptr,document_handle,- parser_insertion_controller,+ parser_bridge,node_id,start_line,start_column,@@ -2338,7 +2341,7 @@ impl DocumentRuntime {} else {self.suspend_document_write_stylesheet_blocked_script(document_handle,- parser_insertion_controller,+ parser_bridge,node_id,start_line,start_column,@@ -2351,7 +2354,7 @@ impl DocumentRuntime {scope,host_ptr,document_handle,- parser_insertion_controller,+ parser_bridge,node_id,start_line,start_column,@@ -2444,10 +2447,10 @@ impl DocumentRuntime {document_handle: DomHandle,html: &str,resume_existing_insertion: bool,- parser_insertion_controller: &ParserInsertionController,+ parser_bridge: &ParserConnectedScriptBridge,) -> bool {- let stream = parser_insertion_controller.parser_stream();- let parser_input_session = parser_insertion_controller.input_session();+ let insertion_controller = parser_bridge.insertion_controller();+ let parser_input_session = insertion_controller.input_session();parser_input_session.enqueue_script_input_preload_html(html.to_owned());let mut chunk = parser_input_session.take_current_script_input_html();@@ -2455,12 +2458,17 @@ impl DocumentRuntime {if chunk.is_empty() && !resume_existing_insertion {return true;}+ // One logical pump session includes processing the tokenizer yield and+ // any synchronous parser continuation it triggers. In particular, a+ // cache-hot external script can suspend and resume recursively before+ // this call returns. Parser finalization must wait for the outermost+ // pump frame, matching Blink's nested PumpTokenizer session boundary.+ let _pump_guard = parser_bridge.begin_pump();let _parser_insertion_session = self.enter_parser_insertion_session();let mut begin_insertion = !chunk.is_empty();loop {let parser_step = {- let _pump_guard = parser_insertion_controller.begin_pump();let input = if begin_insertion {DocumentWriteParserPumpInput::Inserted(chunk.as_str())} else if resume_existing_insertion && chunk.is_empty() {@@ -2473,12 +2481,9 @@ impl DocumentRuntime {} else {DocumentWriteParserPumpInput::Ordinary(chunk.as_str())};- self.pump_document_write_parser_step(- scope,- host_ptr,- &mut stream.borrow_mut(),- input,- )+ insertion_controller.with_parser_stream_mut(|stream| {+ self.pump_document_write_parser_step(scope, host_ptr, stream, input)+ })};let DocumentWriteParserPumpStep {outcome:@@ -2489,9 +2494,10 @@ impl DocumentRuntime {discovered_blocking_stylesheet_inputs,},} = parser_step;- let discovered_parser_meta_csp_candidates = stream- .borrow_mut()- .drain_discovered_parser_meta_csp_candidates();+ let discovered_parser_meta_csp_candidates = insertion_controller+ .with_parser_stream_mut(+ DocumentStream::drain_discovered_parser_meta_csp_candidates,+ );for handle in &discovered_parser_meta_csp_candidates {self.process_parser_meta_content_security_policy(*handle);}@@ -2538,7 +2544,7 @@ impl DocumentRuntime {&& self.suspend_document_write_stylesheet_parser_pause(host_ptr,document_handle,- parser_insertion_controller,+ parser_bridge,pause.node_id,blocking_signatures,)@@ -2551,7 +2557,7 @@ impl DocumentRuntime {scope,host_ptr,document_handle,- parser_insertion_controller,+ parser_bridge,*handoff,) {return true;@@ -2651,11 +2657,11 @@ impl DocumentRuntime {return true;}- let parser_insertion_controller = self+ let parser_bridge = self.root_document_parser.as_ref()- .and_then(ParserInsertionController::for_session)- .or_else(|| self.current_parser_insertion_controller())+ .and_then(ParserConnectedScriptBridge::for_session)+ .or_else(|| self.current_parser_bridge()).expect("document.write() must have a live root stream or parser insertion controller");self.write_html_via_parser_stream(scope,@@ -2663,7 +2669,7 @@ impl DocumentRuntime {document_handle,html,false,- &parser_insertion_controller,+ &parser_bridge,)}}@@ -2755,7 +2761,11 @@ mod tests {.as_ref().expect("root replacement parser session");assert_eq!(parser.lifetime(), DocumentParserLifetime::Open);- assert!(parser.has_exclusive_stream_handle());+ assert_eq!(parser.run_state(), DocumentParserRunState::Ready);+ assert_eq!(+ parser.finish_request_state(),+ crate::live_document_parser::DocumentParserFinishRequestState::NotRequested+ );}#[test]diff --git a/moli-renderer-v8/src/document_runtime/lifecycle.rs b/moli-renderer-v8/src/document_runtime/lifecycle.rsindex 8173c287e..7b1177b30 100644--- a/moli-renderer-v8/src/document_runtime/lifecycle.rs+++ b/moli-renderer-v8/src/document_runtime/lifecycle.rs@@ -435,23 +435,26 @@ impl DocumentRuntime {let CurrentScriptContextSpec {handle,parser_write_insertion_point_active,- parser_insertion_controller,+ parser_bridge,} = spec;let handle = handle.filter(|node| self.dom_host.node(*node).is_some());- let parser_insertion_controller = parser_insertion_controller+ let parser_bridge = parser_bridge.or_else(|| {self.current_script_context().and_then(|context| {context.parser_connected.as_ref()- .map(|parser| parser.insertion_controller.clone())+ .map(|parser| parser.bridge.clone())})}).filter(|_| parser_write_insertion_point_active);- let parser_connected = parser_insertion_controller.map(|insertion_controller| {- let input_context = insertion_controller.input_session().enter_pending_context();+ let parser_connected = parser_bridge.map(|bridge| {+ let input_context = bridge+ .insertion_controller()+ .input_session()+ .enter_pending_context();ParserConnectedScriptContext {- insertion_controller,+ bridge,_input_context: input_context,}});@@ -474,10 +477,10 @@ impl DocumentRuntime {.is_some_and(|context| context.parser_connected.is_some())}- pub(super) fn current_parser_insertion_controller(&self) -> Option<ParserInsertionController> {+ pub(super) fn current_parser_bridge(&self) -> Option<ParserConnectedScriptBridge> {self.current_script_context().and_then(|context| context.parser_connected.as_ref())- .map(|context| context.insertion_controller.clone())+ .map(|context| context.bridge.clone())}pub(crate) fn take_post_parse_schedule_invalidated(&mut self) -> bool {@@ -581,7 +584,7 @@ mod tests {};use super::{- CurrentScriptContextSpec, DocumentRuntime, DomHandle, ParserInsertionController,+ CurrentScriptContextSpec, DocumentRuntime, DomHandle, ParserConnectedScriptBridge,PostParsePageTaskPopBlocker,};@@ -632,12 +635,12 @@ mod tests {runtime.set_current_script_context(CurrentScriptContextSpec {handle: None,parser_write_insertion_point_active: true,- parser_insertion_controller: Some(ParserInsertionController::for_stream(stream)),+ parser_bridge: Some(ParserConnectedScriptBridge::for_stream(&stream)),});assert_eq!(runtime.current_script_handle(), None);assert!(runtime.has_active_parser_write_insertion_point());- assert!(runtime.current_parser_insertion_controller().is_some());+ assert!(runtime.current_parser_bridge().is_some());}fn modulepreload_as_matrix_markup(base_href: &str) -> String {diff --git a/moli-renderer-v8/src/document_runtime/script_scheduling/document_write_scripts.rs b/moli-renderer-v8/src/document_runtime/script_scheduling/document_write_scripts.rsindex 88d063b03..22df7442a 100644--- a/moli-renderer-v8/src/document_runtime/script_scheduling/document_write_scripts.rs+++ b/moli-renderer-v8/src/document_runtime/script_scheduling/document_write_scripts.rs@@ -30,7 +30,7 @@ impl DocumentRuntime {host_ptr: *mut JsContextHost,node: DomHandle,mut script: PreparedScript,- parser_insertion_controller: Option<ParserInsertionController>,+ parser_bridge: Option<ParserConnectedScriptBridge>,) -> DocumentWriteScriptRunOutcome {if !self.dom_host@@ -110,7 +110,7 @@ impl DocumentRuntime {node,&host_script_handle,source,- parser_insertion_controller,+ parser_bridge,DocumentWriteCurrentScriptEventBehavior::Skip,);DocumentWriteScriptRunOutcome::Complete@@ -121,7 +121,7 @@ impl DocumentRuntime {node,&host_script_handle,script,- parser_insertion_controller,+ parser_bridge,)}}@@ -133,13 +133,13 @@ impl DocumentRuntime {node: DomHandle,host_script_handle: &str,source: String,- parser_insertion_controller: Option<ParserInsertionController>,+ parser_bridge: Option<ParserConnectedScriptBridge>,current_script_event_behavior: DocumentWriteCurrentScriptEventBehavior,) {self.set_current_script_context(CurrentScriptContextSpec {handle: Some(node),parser_write_insertion_point_active: true,- parser_insertion_controller,+ parser_bridge,});// A parser-created script belongs to the document's main world even// when an isolated/utility world called document.write(). Blink's@@ -211,7 +211,7 @@ impl DocumentRuntime {node: DomHandle,host_script_handle: &str,script: PreparedScript,- parser_insertion_controller: Option<ParserInsertionController>,+ parser_bridge: Option<ParserConnectedScriptBridge>,) -> DocumentWriteScriptRunOutcome {if script.kind == ScriptKind::ImportMap&& script.source_kind == crate::ScriptSourceKind::Inline@@ -288,7 +288,7 @@ impl DocumentRuntime {node,host_script_handle,source,- parser_insertion_controller,+ parser_bridge,DocumentWriteCurrentScriptEventBehavior::DispatchImmediately(ScriptEventKind::Load),);DocumentWriteScriptRunOutcome::Completediff --git a/moli-renderer-v8/src/live_document_parser.rs b/moli-renderer-v8/src/live_document_parser.rsindex 1160c660d..865c2708e 100644--- a/moli-renderer-v8/src/live_document_parser.rs+++ b/moli-renderer-v8/src/live_document_parser.rs@@ -225,7 +225,7 @@ pub(crate) enum ParserStopReason {pub(crate) enum DocumentParserRunState {Ready,Pumping {- epoch: u64,+ nesting_level: usize,},Suspended {id: ParserSuspensionId,@@ -236,7 +236,42 @@ pub(crate) enum DocumentParserRunState {Stopped(ParserStopReason),}-impl From<ParserSuspension> for DocumentParserRunState {+/// Tracks a live parser's end request separately from its current execution+/// state.+///+/// `DocumentParserRunState` is the public projection used by callers; pump+/// nesting is recorded independently so a suspended nested pump can retain+/// both facts. This state answers whether EOF has requested finalization and+/// whether the owning parser's safe boundary has admitted a previously delayed+/// finish.+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]+pub(crate) enum DocumentParserFinishRequestState {+ /// The parser owner can still append ordinary outer input.+ #[default]+ NotRequested,+ /// EOF/close was requested and no unsafe end attempt has been observed.+ Requested,+ /// The request overlapped a pump, suspension, or parser-script scope and+ /// must cross the parser owner's next stable boundary before finalizing.+ Delayed,+ /// The stable owner boundary admitted this delayed finish exactly once.+ /// Entering more parser work consumes the admission.+ Admitted,+}++#[derive(Clone, Copy, Debug, PartialEq, Eq)]+enum DocumentParserLifecycleState {+ Ready,+ Suspended {+ id: ParserSuspensionId,+ cause: ParserSuspensionCause,+ },+ Finishing,+ Finished,+ Stopped(ParserStopReason),+}++impl From<ParserSuspension> for DocumentParserLifecycleState {fn from(suspension: ParserSuspension) -> Self {Self::Suspended {id: suspension.id,@@ -245,21 +280,34 @@ impl From<ParserSuspension> for DocumentParserRunState {}}-impl DocumentParserRunState {+impl DocumentParserLifecycleState {fn suspension(self) -> Option<ParserSuspension> {match self {Self::Suspended { id, cause } => Some(ParserSuspension { id, cause }),_ => None,}}++ fn observed_run_state(self, pump_session_nesting_level: usize) -> DocumentParserRunState {+ match (self, pump_session_nesting_level) {+ (Self::Ready, nesting_level @ 1..) => DocumentParserRunState::Pumping { nesting_level },+ (Self::Ready, 0) => DocumentParserRunState::Ready,+ (Self::Suspended { id, cause }, _) => DocumentParserRunState::Suspended { id, cause },+ (Self::Finishing, _) => DocumentParserRunState::Finishing,+ (Self::Finished, _) => DocumentParserRunState::Finished,+ (Self::Stopped(reason), _) => DocumentParserRunState::Stopped(reason),+ }+ }}#[derive(Debug)]struct DocumentParserSessionControl {session_id: ParserSessionId,next_suspension_id: u64,- next_pump_epoch: u64,- run_state: DocumentParserRunState,+ pump_session_nesting_level: usize,+ lifecycle_state: DocumentParserLifecycleState,+ parser_script_nesting_level: usize,+ finish_request_state: DocumentParserFinishRequestState,}#[derive(Clone, Debug)]@@ -272,8 +320,10 @@ impl DocumentParserSessionControlHandle {Self(Rc::new(RefCell::new(DocumentParserSessionControl {session_id,next_suspension_id: 1,- next_pump_epoch: 1,- run_state: DocumentParserRunState::Ready,+ pump_session_nesting_level: 0,+ lifecycle_state: DocumentParserLifecycleState::Ready,+ parser_script_nesting_level: 0,+ finish_request_state: DocumentParserFinishRequestState::NotRequested,})))}@@ -282,15 +332,89 @@ impl DocumentParserSessionControlHandle {}pub(crate) fn run_state(&self) -> DocumentParserRunState {- self.0.borrow().run_state+ let control = self.0.borrow();+ control+ .lifecycle_state+ .observed_run_state(control.pump_session_nesting_level)+ }++ pub(crate) fn parser_script_nesting_level(&self) -> usize {+ self.0.borrow().parser_script_nesting_level+ }++ pub(crate) fn pump_session_nesting_level(&self) -> usize {+ self.0.borrow().pump_session_nesting_level+ }++ pub(crate) fn finish_request_state(&self) -> DocumentParserFinishRequestState {+ self.0.borrow().finish_request_state+ }++ pub(crate) fn enter_parser_script_nesting(&self) -> DocumentParserScriptNestingGuard {+ let mut control = self.0.borrow_mut();+ assert!(+ !matches!(+ control.lifecycle_state,+ DocumentParserLifecycleState::Finishing+ | DocumentParserLifecycleState::Finished+ | DocumentParserLifecycleState::Stopped(_)+ ),+ "a terminal live parser cannot enter parser-script execution"+ );+ control.parser_script_nesting_level = control+ .parser_script_nesting_level+ .checked_add(1)+ .expect("live parser script nesting level overflow");+ if control.finish_request_state == DocumentParserFinishRequestState::Admitted {+ // Admission authorizes the delayed finish at one exact boundary;+ // entering more parser-connected work consumes that authority.+ control.finish_request_state = DocumentParserFinishRequestState::Requested;+ }+ drop(control);+ DocumentParserScriptNestingGuard {+ control: self.clone(),+ }+ }++ fn request_finish(&self) {+ let mut control = self.0.borrow_mut();+ let finish_is_unsafe = control.pump_session_nesting_level > 0+ || matches!(+ control.lifecycle_state,+ DocumentParserLifecycleState::Suspended { .. }+ )+ || control.parser_script_nesting_level > 0;+ match (control.finish_request_state, finish_is_unsafe) {+ (DocumentParserFinishRequestState::Delayed, _) => {}+ (_, true) => {+ control.finish_request_state = DocumentParserFinishRequestState::Delayed;+ }+ (DocumentParserFinishRequestState::NotRequested, false) => {+ control.finish_request_state = DocumentParserFinishRequestState::Requested;+ }+ (+ DocumentParserFinishRequestState::Requested+ | DocumentParserFinishRequestState::Admitted,+ false,+ ) => {}+ }+ }++ fn admit_delayed_finish(&self) -> bool {+ let mut control = self.0.borrow_mut();+ if control.finish_request_state != DocumentParserFinishRequestState::Delayed {+ return false;+ }+ control.finish_request_state = DocumentParserFinishRequestState::Admitted;+ true}pub(crate) fn suspend(&self, cause: ParserSuspensionCause) -> ParserResumePermit {let mut control = self.0.borrow_mut();assert_eq!(- control.run_state,- DocumentParserRunState::Ready,- "only a ready live parser session can enter a persistent suspension"+ control.lifecycle_state,+ DocumentParserLifecycleState::Ready,+ "only a live parser without an existing suspension can enter a persistent suspension");let suspension_id = ParserSuspensionId(control.next_suspension_id);control.next_suspension_id = control@@ -301,7 +425,14 @@ impl DocumentParserSessionControlHandle {id: suspension_id,cause,};- control.run_state = suspension.into();+ if matches!(+ control.finish_request_state,+ DocumentParserFinishRequestState::Requested+ | DocumentParserFinishRequestState::Admitted+ ) {+ control.finish_request_state = DocumentParserFinishRequestState::Delayed;+ }+ control.lifecycle_state = suspension.into();ParserResumePermit {session_id: control.session_id,suspension_id,@@ -310,7 +441,7 @@ impl DocumentParserSessionControlHandle {pub(crate) fn current_resume_permit(&self) -> Option<ParserResumePermit> {let control = self.0.borrow();- let suspension = control.run_state.suspension()?;+ let suspension = control.lifecycle_state.suspension()?;Some(ParserResumePermit {session_id: control.session_id,suspension_id: suspension.id,@@ -322,75 +453,115 @@ impl DocumentParserSessionControlHandle {if permit.session_id != control.session_id {return false;}- let Some(suspension) = control.run_state.suspension() else {+ let Some(suspension) = control.lifecycle_state.suspension() else {return false;};if suspension.id != permit.suspension_id {return false;}- control.run_state = DocumentParserRunState::Ready;+ control.lifecycle_state = DocumentParserLifecycleState::Ready;true}pub(crate) fn begin_pump(&self) -> DocumentParserPumpGuard {let mut control = self.0.borrow_mut();assert_eq!(- control.run_state,- DocumentParserRunState::Ready,- "a live parser may only pump from the ready state"+ control.lifecycle_state,+ DocumentParserLifecycleState::Ready,+ "a suspended or terminal live parser cannot enter a pump session");- let epoch = control.next_pump_epoch;- control.next_pump_epoch = control.next_pump_epoch.wrapping_add(1).max(1);- control.run_state = DocumentParserRunState::Pumping { epoch };+ control.pump_session_nesting_level = control+ .pump_session_nesting_level+ .checked_add(1)+ .expect("live parser pump session nesting level overflow");+ let nesting_level = control.pump_session_nesting_level;+ if control.finish_request_state == DocumentParserFinishRequestState::Admitted {+ // A continuation admission is a one-shot finish authority, not a+ // blanket permit for arbitrary subsequent parser work.+ control.finish_request_state = DocumentParserFinishRequestState::Requested;+ }drop(control);DocumentParserPumpGuard {control: self.clone(),- epoch,+ nesting_level,}}fn begin_finish(&self) {let mut control = self.0.borrow_mut();assert_eq!(- control.run_state,- DocumentParserRunState::Ready,+ control.lifecycle_state,+ DocumentParserLifecycleState::Ready,"a suspended or stopped live parser cannot finish");- control.run_state = DocumentParserRunState::Finishing;+ assert!(+ control.pump_session_nesting_level == 0,+ "a live parser cannot finish inside an active pump session"+ );+ assert_eq!(+ control.parser_script_nesting_level, 0,+ "a live parser cannot finish while a parser-connected script is executing"+ );+ assert!(+ matches!(+ control.finish_request_state,+ DocumentParserFinishRequestState::Requested+ | DocumentParserFinishRequestState::Admitted+ ),+ "parser finish requires an undelayed finish request"+ );+ control.lifecycle_state = DocumentParserLifecycleState::Finishing;}fn finish(&self) {let mut control = self.0.borrow_mut();assert_eq!(- control.run_state,- DocumentParserRunState::Finishing,+ control.lifecycle_state,+ DocumentParserLifecycleState::Finishing,"parser finish must complete the active finishing transition");- control.run_state = DocumentParserRunState::Finished;+ control.lifecycle_state = DocumentParserLifecycleState::Finished;}pub(crate) fn stop(&self, reason: ParserStopReason) {let mut control = self.0.borrow_mut();if !matches!(- control.run_state,- DocumentParserRunState::Finished | DocumentParserRunState::Stopped(_)+ control.lifecycle_state,+ DocumentParserLifecycleState::Finished | DocumentParserLifecycleState::Stopped(_)) {- control.run_state = DocumentParserRunState::Stopped(reason);+ control.lifecycle_state = DocumentParserLifecycleState::Stopped(reason);}}}pub(crate) struct DocumentParserPumpGuard {control: DocumentParserSessionControlHandle,- epoch: u64,+ nesting_level: usize,+}++pub(crate) struct DocumentParserScriptNestingGuard {+ control: DocumentParserSessionControlHandle,+}++impl Drop for DocumentParserScriptNestingGuard {+ fn drop(&mut self) {+ let mut control = self.control.0.borrow_mut();+ assert!(+ control.parser_script_nesting_level > 0,+ "parser script nesting guard exited without matching enter"+ );+ control.parser_script_nesting_level -= 1;+ }}impl Drop for DocumentParserPumpGuard {fn drop(&mut self) {let mut control = self.control.0.borrow_mut();- if control.run_state == (DocumentParserRunState::Pumping { epoch: self.epoch }) {- control.run_state = DocumentParserRunState::Ready;- }+ assert_eq!(+ control.pump_session_nesting_level, self.nesting_level,+ "live parser pump sessions must unwind in stack order"+ );+ control.pump_session_nesting_level -= 1;}}@@ -434,6 +605,15 @@ impl std::fmt::Debug for DocumentParserSession {.field("lifetime", &self.lifetime).field("session_id", &self.control.session_id()).field("run_state", &self.control.run_state())+ .field(+ "pump_session_nesting_level",+ &self.control.pump_session_nesting_level(),+ )+ .field(+ "parser_script_nesting_level",+ &self.control.parser_script_nesting_level(),+ )+ .field("finish_request_state", &self.control.finish_request_state()).finish_non_exhaustive()}}@@ -571,6 +751,20 @@ impl DocumentParserSession {self.control.run_state()}+ pub(crate) fn finish_request_state(&self) -> DocumentParserFinishRequestState {+ self.control.finish_request_state()+ }++ pub(crate) fn can_finish_now(&self) -> bool {+ self.run_state() == DocumentParserRunState::Ready+ && self.control.parser_script_nesting_level() == 0+ && matches!(+ self.finish_request_state(),+ DocumentParserFinishRequestState::Requested+ | DocumentParserFinishRequestState::Admitted+ )+ }+pub(crate) fn control_handle(&self) -> DocumentParserSessionControlHandle {self.control.clone()}@@ -609,7 +803,10 @@ impl DocumentParserSession {pub(crate) fn request_close(&mut self) -> DocumentParserCloseDisposition {self.lifetime = DocumentParserLifetime::Closing;- if self.run_state() == DocumentParserRunState::Ready {+ self.control.request_finish();+ if self.run_state() == DocumentParserRunState::Ready+ && self.control.parser_script_nesting_level() == 0+ {DocumentParserCloseDisposition::DrainNow} else {DocumentParserCloseDisposition::DeferredUntilReady@@ -628,14 +825,29 @@ impl DocumentParserSession {}pub(crate) fn suspension_cause(&self) -> Option<ParserSuspensionCause> {- self.run_state().suspension().map(|pause| pause.cause)+ match self.run_state() {+ DocumentParserRunState::Suspended { cause, .. } => Some(cause),+ _ => None,+ }}- pub(crate) fn has_exclusive_stream_handle(&self) -> bool {- match self.backend() {- ExecutableDocumentParserBackend::Html(stream) => Rc::strong_count(stream) == 1,- ExecutableDocumentParserBackend::Xml(stream) => Rc::strong_count(stream) == 1,+ /// Record that no more ordinary outer input will arrive. Whether this can+ /// finish synchronously is decided later, after parser input is drained.+ pub(crate) fn request_finish(&mut self) {+ self.control.request_finish();+ }++ pub(crate) fn admit_delayed_finish_continuation(&mut self) -> bool {+ self.control.admit_delayed_finish()+ }++ pub(crate) fn admit_delayed_finish_at_local_owner_boundary(&mut self) -> bool {+ if self.run_state() != DocumentParserRunState::Ready+ || self.control.parser_script_nesting_level() > 0+ {+ return false;}+ self.control.admit_delayed_finish()}pub(crate) fn note_defined_autonomous_custom_elements(@@ -1067,4 +1279,159 @@ mod session_state_tests {DocumentParserRunState::Stopped(ParserStopReason::OwnerDropped));}++ #[test]+ fn nested_pump_and_suspension_keep_finish_delayed_until_outermost_boundary() {+ let mut parser = session();+ let control = parser.control_handle();+ parser.request_finish();++ let outer_pump = control.begin_pump();+ let outer_pump_state = control.run_state();+ assert_eq!(control.pump_session_nesting_level(), 1);+ parser.request_finish();+ assert_eq!(+ parser.finish_request_state(),+ DocumentParserFinishRequestState::Delayed+ );++ let permit = parser.suspend(ParserSuspensionCause::ParserCreatedStylesheet {+ owner: NativeNodeId::new(2),+ });+ assert!(matches!(+ parser.run_state(),+ DocumentParserRunState::Suspended { .. }+ ));+ assert_eq!(+ control.pump_session_nesting_level(),+ 1,+ "persistent suspension must not erase the resident outer pump frame"+ );+ assert!(parser.resume(permit));+ assert_eq!(+ parser.run_state(),+ outer_pump_state,+ "resuming a nested blocker must reveal the still-active outer pump"+ );++ {+ let _nested_pump = control.begin_pump();+ assert_eq!(control.pump_session_nesting_level(), 2);+ assert_ne!(parser.run_state(), outer_pump_state);+ assert!(!parser.admit_delayed_finish_at_local_owner_boundary());+ }+ assert_eq!(control.pump_session_nesting_level(), 1);+ assert_eq!(parser.run_state(), outer_pump_state);+ drop(outer_pump);++ assert_eq!(control.pump_session_nesting_level(), 0);+ assert_eq!(parser.run_state(), DocumentParserRunState::Ready);+ assert!(parser.admit_delayed_finish_at_local_owner_boundary());+ assert!(parser.can_finish_now());+ }++ #[test]+ fn phase_one_finish_is_delayed_until_exact_continuation_admission() {+ let mut parser = session();+ let control = parser.control_handle();++ {+ let _pump = control.begin_pump();+ parser.request_finish();+ }+ assert_eq!(+ parser.finish_request_state(),+ DocumentParserFinishRequestState::Delayed+ );+ assert!(+ !parser.can_finish_now(),+ "recording EOF must not grant parser destruction authority"+ );++ assert!(parser.admit_delayed_finish_continuation());+ assert_eq!(+ parser.finish_request_state(),+ DocumentParserFinishRequestState::Admitted+ );+ assert!(parser.can_finish_now());+ assert!(+ !parser.admit_delayed_finish_continuation(),+ "one selected continuation can only admit the delayed finish once"+ );+ }++ #[test]+ fn parser_script_nesting_blocks_a_requested_finish() {+ let mut parser = DocumentParserSession::start_open_live_document(+ Url::parse("https://parser-session.test/").expect("test URL"),+ NativeNodeId::new(1),+ );+ let control = parser.control_handle();+ let nesting = control.enter_parser_script_nesting();++ assert_eq!(+ parser.request_close(),+ DocumentParserCloseDisposition::DeferredUntilReady+ );++ assert_eq!(control.parser_script_nesting_level(), 1);+ assert_eq!(+ parser.finish_request_state(),+ DocumentParserFinishRequestState::Delayed+ );+ assert!(!parser.can_finish_now());++ drop(nesting);+ assert_eq!(control.parser_script_nesting_level(), 0);+ assert!(+ !parser.can_finish_now(),+ "leaving script execution must not silently erase the delayed-end fact"+ );+ assert!(parser.admit_delayed_finish_at_local_owner_boundary());+ assert!(parser.can_finish_now());+ }++ #[test]+ fn completed_parser_script_does_not_delay_a_preexisting_finish_request() {+ let mut parser = session();+ let control = parser.control_handle();++ parser.request_finish();+ let nesting = control.enter_parser_script_nesting();+ assert!(!parser.can_finish_now());+ drop(nesting);++ assert_eq!(+ parser.finish_request_state(),+ DocumentParserFinishRequestState::Requested+ );+ assert!(parser.can_finish_now());+ }++ #[test]+ fn new_parser_work_consumes_delayed_finish_admission() {+ let mut parser = session();+ let control = parser.control_handle();+ let nesting = control.enter_parser_script_nesting();+ parser.request_finish();+ drop(nesting);+ assert!(parser.admit_delayed_finish_continuation());++ {+ let _pump = control.begin_pump();+ assert_eq!(+ parser.finish_request_state(),+ DocumentParserFinishRequestState::Requested+ );+ }+ let permit = parser.suspend(ParserSuspensionCause::ParserCreatedStylesheet {+ owner: NativeNodeId::new(2),+ });+ assert_eq!(+ parser.finish_request_state(),+ DocumentParserFinishRequestState::Delayed+ );+ assert!(parser.resume(permit));+ assert!(!parser.can_finish_now());+ }}diff --git a/moli-renderer-v8/src/native_bridge/context_host/child_documents/live_parser.rs b/moli-renderer-v8/src/native_bridge/context_host/child_documents/live_parser.rsindex 9708da138..eebb70f7a 100644--- a/moli-renderer-v8/src/native_bridge/context_host/child_documents/live_parser.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/child_documents/live_parser.rs@@ -883,6 +883,8 @@ impl JsContextHost {document_handle: DomHandle,mut parser: DocumentParserSession,) -> Option<crate::frame_owner_model::FrameDocumentInteractiveLifecycleAction> {+ parser.request_finish();+ let _ = parser.admit_delayed_finish_at_local_owner_boundary();let finish_signals = {let mut owner = ChildFrameLiveParserOwner::new(self, scope, document_handle);parser.finish(&mut owner)diff --git a/moli-renderer-v8/src/runtime/phase_one/bootstrap.rs b/moli-renderer-v8/src/runtime/phase_one/bootstrap.rsindex c1d166b90..8ee733368 100644--- a/moli-renderer-v8/src/runtime/phase_one/bootstrap.rs+++ b/moli-renderer-v8/src/runtime/phase_one/bootstrap.rs@@ -106,7 +106,7 @@ impl ConcurrentParseTimeRuntime {service_worker_preload_context.as_ref(),);state.parser_session.queue_arrived_chunk(html);- state.input_closed = true;+ state.close_input();let (state, page_vm, triggered_navigation) =Self::bootstrap_page_vm_from_state_on_fresh_local_task(page_id,@@ -189,7 +189,7 @@ impl ConcurrentParseTimeRuntime {);state.parser_session.queue_arrived_chunk(source);state.parser_session.declare_eof();- state.input_closed = true;+ state.close_input();let (state, page_vm, triggered_navigation) =Self::bootstrap_page_vm_from_state_on_fresh_local_task(page_id,diff --git a/moli-renderer-v8/src/runtime/phase_one/mod.rs b/moli-renderer-v8/src/runtime/phase_one/mod.rsindex 523e5b4b8..120f6a647 100644--- a/moli-renderer-v8/src/runtime/phase_one/mod.rs+++ b/moli-renderer-v8/src/runtime/phase_one/mod.rs@@ -3871,14 +3871,14 @@ document.body.setAttribute('data-error-state', [}#[test]- fn main_parser_finish_waits_for_transient_insertion_controller() {+ fn main_parser_finish_waits_for_phase_one_continuation_boundary() {run_phase_one_large_stack_test(- "phase-one-main-parser-finish-after-insertion-controller",- main_parser_finish_waits_for_transient_insertion_controller_inner,+ "phase-one-main-parser-finish-after-continuation-boundary",+ main_parser_finish_waits_for_phase_one_continuation_boundary_inner,);}- fn main_parser_finish_waits_for_transient_insertion_controller_inner() {+ fn main_parser_finish_waits_for_phase_one_continuation_boundary_inner() {let runtime = tokio::runtime::Builder::new_current_thread().enable_all().build()@@ -3891,12 +3891,22 @@ document.body.setAttribute('data-error-state', [ResourceRequestClient::new(&FetchConfig::default()).expect("default loader");let loader = loader_owner.clone();let mut state = ParseTimeDriverState::new(final_url);- state.input_closed = true;- let insertion_controller =- crate::document_runtime::ParserInsertionController::for_session(+ state.close_input();+ let parser_bridge =+ crate::document_runtime::ParserConnectedScriptBridge::for_session(&state.parser_session,)- .expect("HTML parser should expose an insertion controller");+ .expect("HTML parser should expose a parser-connected script bridge");+ let resume_permit = parser_bridge.suspend(+ crate::live_document_parser::ParserSuspensionCause::ParserCreatedStylesheet {+ owner: crate::dom::native::NativeNodeId::new(1),+ },+ );+ assert_eq!(+ state.parser_session.finish_request_state(),+ crate::live_document_parser::DocumentParserFinishRequestState::Delayed+ );+ assert!(parser_bridge.resume(resume_permit));let parser_dom_host = state.parser_session.stream_handle()@@ -3923,13 +3933,18 @@ document.body.setAttribute('data-error-state', [let completion = ParseTimePhaseOnePump::new(phase_runtime).run_to_completion().await- .expect("borrowed parser stream should park instead of finishing");+ .expect("EOF should park instead of finishing in the requesting turn");let super::loop_protocol::ParseTimeOwnerCompletion::PendingPageTask(mut phase_runtime,) = completionelse {- panic!("borrowed parser stream should publish one continuation task");+ panic!("EOF should publish one phase-one continuation task");};+ assert_eq!(+ phase_runtime.state.parser_session.finish_request_state(),+ crate::live_document_parser::DocumentParserFinishRequestState::Delayed,+ "the requesting turn must record an explicitly delayed finish"+ );assert!(phase_runtime.page_vm@@ -3947,7 +3962,6 @@ document.body.setAttribute('data-error-state', ["deferred finish must cross a selected Page task boundary");- drop(insertion_controller);let request_client = phase_runtime.page_vm.main_document_resource_loader()@@ -3965,17 +3979,28 @@ document.body.setAttribute('data-error-state', ["the exact deferred-finish continuation should remain selectable");+ // Keep the insertion bridge alive across finalization. Its weak+ // stream capability must not participate in parser ownership.let completion = ParseTimePhaseOnePump::new(phase_runtime).run_to_completion().await- .expect("unborrowed parser stream should finish");- assert!(matches!(- completion,- super::loop_protocol::ParseTimeOwnerCompletion::AdvancePhase {- reason: super::loop_protocol::ParseTimePhaseTransitionReason::ParserCompleted,- ..- }- ));+ .expect("admitted parser continuation should finish");+ let super::loop_protocol::ParseTimeOwnerCompletion::AdvancePhase {+ runtime,+ reason: super::loop_protocol::ParseTimePhaseTransitionReason::ParserCompleted,+ } = completion+ else {+ panic!("the admitted delayed finish should advance to phase two");+ };+ assert_eq!(+ runtime.state.parser_session.run_state(),+ crate::live_document_parser::DocumentParserRunState::Finished+ );+ assert_eq!(+ runtime.state.parser_session.finish_request_state(),+ crate::live_document_parser::DocumentParserFinishRequestState::Admitted+ );+ drop(parser_bridge);}));}@@ -4605,14 +4630,14 @@ queueMicrotask(() => window.__mainParserClassicCheckpointEvents.push('script-mic);let mut pending_runner =PendingParsingBlockingClassicScriptRunner::new_parser_blocking(Vec::new());- let parser_insertion_controller =- crate::document_runtime::ParserInsertionController::for_session(+ let parser_bridge =+ crate::document_runtime::ParserConnectedScriptBridge::for_session(&state.parser_session,);let mut owner = super::parser_blocking_document_script::MainParserBlockingDocumentScriptOwner::new(&mut page_vm,&mut pending_runner,- parser_insertion_controller,+ parser_bridge,"test source failure",);diff --git a/moli-renderer-v8/src/runtime/phase_one/owner_turn.rs b/moli-renderer-v8/src/runtime/phase_one/owner_turn.rsindex 3e8e7e6c6..240b353a4 100644--- a/moli-renderer-v8/src/runtime/phase_one/owner_turn.rs+++ b/moli-renderer-v8/src/runtime/phase_one/owner_turn.rs@@ -246,7 +246,14 @@ impl ConcurrentParseTimeRuntime {&& !state.parser_session.has_script_input(){if state.input_closed {- OwnerStepProgress::AdvancePhase+ // Document work can expose EOF, but+ // only the phase-one parser owner may+ // request and claim finalization. Route+ // through it so the exact continuation+ // boundary remains mandatory.+ *parser_step_ready = true;+ *owner = ParseTimeOwner::Parser;+ OwnerStepProgress::Continue} else {*owner = ParseTimeOwner::Parser;OwnerStepProgress::NeedMoreInputdiff --git a/moli-renderer-v8/src/runtime/phase_one/parser_blocking_document_script.rs b/moli-renderer-v8/src/runtime/phase_one/parser_blocking_document_script.rsindex be74b076d..3cf914084 100644--- a/moli-renderer-v8/src/runtime/phase_one/parser_blocking_document_script.rs+++ b/moli-renderer-v8/src/runtime/phase_one/parser_blocking_document_script.rs@@ -14,7 +14,7 @@ use super::parser_blocking_task::{MainParserBlockingNextAction,};use super::*;-use crate::document_runtime::ParserInsertionController;+use crate::document_runtime::ParserConnectedScriptBridge;use crate::document_script_scheduler::{DocumentScriptExecutionOutcome, ParserClassicDocumentScriptCompletionPlan,ParserClassicDocumentScriptContinuation, ParserClassicDocumentScriptExecutionHooks,@@ -33,7 +33,7 @@ use crate::script_vm::{pub(super) struct MainParserBlockingDocumentScriptOwner<'page, 'runner> {page_vm: &'page mut PageVm,pending_runner: &'runner mut PendingParsingBlockingClassicScriptRunner,- parser_insertion_controller: Option<ParserInsertionController>,+ parser_bridge: Option<ParserConnectedScriptBridge>,log_message: &'static str,}@@ -59,13 +59,13 @@ impl<'page, 'runner> MainParserBlockingDocumentScriptOwner<'page, 'runner> {pub(super) fn new(page_vm: &'page mut PageVm,pending_runner: &'runner mut PendingParsingBlockingClassicScriptRunner,- parser_insertion_controller: Option<ParserInsertionController>,+ parser_bridge: Option<ParserConnectedScriptBridge>,log_message: &'static str,) -> Self {Self {page_vm,pending_runner,- parser_insertion_controller,+ parser_bridge,log_message,}}@@ -149,9 +149,9 @@ impl ParserClassicDocumentScriptExecutionHookslet owner = &mut **self;let script_handle = ready_script.script_handle();let completion_target = *ready_script.target();- let parser_insertion_controller = owner.parser_insertion_controller.clone();+ let parser_bridge = owner.parser_bridge.clone();let mut begin_owner = MainParserBlockingBeginExecutionOwner {- parser_insertion_controller,+ parser_bridge,completion_target,};let Some(execution_entry) = owner@@ -186,7 +186,7 @@ impl ParserClassicDocumentScriptExecutionHookslet completion_target = target.completion_target();let live_execution = ParseTimeLiveExecution::ParserOwnedClassicScript {execution_context: ParserOwnedClassicScriptExecutionContext::ParserBlocking {- insertion_controller: target.parser_insertion_controller(),+ parser_bridge: target.parser_bridge(),},script: Box::new(executable_script.into_prepared_script()),};@@ -272,7 +272,7 @@ impl ParserClassicDocumentScriptExecutionHookslet completion = MainParserBlockingClassicScriptCompletionAction::new(target,ParserOwnedClassicScriptCompletion::parser_blocking_source_failure(- owner.parser_insertion_controller.clone(),+ owner.parser_bridge.clone(),event,),);diff --git a/moli-renderer-v8/src/runtime/phase_one/parser_blocking_execution.rs b/moli-renderer-v8/src/runtime/phase_one/parser_blocking_execution.rsindex ca1d6f8ef..46060a5f8 100644--- a/moli-renderer-v8/src/runtime/phase_one/parser_blocking_execution.rs+++ b/moli-renderer-v8/src/runtime/phase_one/parser_blocking_execution.rs@@ -3,7 +3,7 @@ use super::parser_blocking_owner::MainParserBlockingExecutionGateOwner;use super::parser_blocking_pending::PendingParsingBlockingClassicScriptRunner;use super::parser_blocking_task::PendingParsingBlockingClassicScriptBlockedOnExecution;use super::*;-use crate::document_runtime::ParserInsertionController;+use crate::document_runtime::ParserConnectedScriptBridge;use crate::document_script_scheduler::DocumentScriptExecutionOutcome;use crate::live_document_parser::{DocumentParserSession, ParserStopReason};use crate::parser_script::owner::ParserScriptExecutionBlocker;@@ -60,7 +60,7 @@ pub(super) async fn resolve_main_parser_blocking_classic_after_runtime_gate(parser_session.stop(ParserStopReason::DocumentReplacement);return Ok(MainParserBlockingExecutionOutcome::StoppedCurrentDocument);}- let parser_insertion_controller = ParserInsertionController::for_session(parser_session);+ let parser_bridge = ParserConnectedScriptBridge::for_session(parser_session);page_vm.vm_mut().sync_live_document_style_sources();let next_projection = {let mut owner = MainParserBlockingExecutionGateOwner { page_vm };@@ -70,7 +70,7 @@ pub(super) async fn resolve_main_parser_blocking_classic_after_runtime_gate(let mut document_script_owner = MainParserBlockingDocumentScriptOwner::new(page_vm,pending_runner,- parser_insertion_controller,+ parser_bridge,log_message,);let action = match next_projection {diff --git a/moli-renderer-v8/src/runtime/phase_one/parser_blocking_owner.rs b/moli-renderer-v8/src/runtime/phase_one/parser_blocking_owner.rsindex 0829bd77a..b52738147 100644--- a/moli-renderer-v8/src/runtime/phase_one/parser_blocking_owner.rs+++ b/moli-renderer-v8/src/runtime/phase_one/parser_blocking_owner.rs@@ -9,7 +9,7 @@ use super::parser_blocking_task::{};use super::*;use crate::DocumentBlockingStylesheetSignature;-use crate::document_runtime::ParserInsertionController;+use crate::document_runtime::ParserConnectedScriptBridge;use crate::document_script_scheduler::MainDocumentClassicScriptTarget;use crate::frame_owner_model::FrameDocumentTaskOwner;use crate::parser_script::action::{@@ -44,7 +44,7 @@ pub(super) struct MainParserBlockingExecutionGateOwner<'a> {}pub(super) struct MainParserBlockingBeginExecutionOwner {- pub(super) parser_insertion_controller: Option<ParserInsertionController>,+ pub(super) parser_bridge: Option<ParserConnectedScriptBridge>,pub(super) completion_target: MainDocumentClassicScriptTarget,}@@ -308,7 +308,7 @@ impl ParserScriptBeginExecutionOwner<PendingParsingBlockingClassicScriptContext>action: ParserPendingClassicScriptBeginExecutionAction,) -> Option<Self::BeginExecutionAction> {Some(main_parser_blocking_begin_execution_action(- self.parser_insertion_controller.clone(),+ self.parser_bridge.clone(),self.completion_target,action,))diff --git a/moli-renderer-v8/src/runtime/phase_one/parser_blocking_task.rs b/moli-renderer-v8/src/runtime/phase_one/parser_blocking_task.rsindex 00b0d2b93..1de32538c 100644--- a/moli-renderer-v8/src/runtime/phase_one/parser_blocking_task.rs+++ b/moli-renderer-v8/src/runtime/phase_one/parser_blocking_task.rs@@ -1,7 +1,7 @@use super::parser_blocking_pending::{PendingParsingBlockingClassicScript, PendingParsingBlockingClassicScriptContext,};-use crate::document_runtime::ParserInsertionController;+use crate::document_runtime::ParserConnectedScriptBridge;use crate::document_script_scheduler::{MainDocumentClassicReadyWork, MainDocumentClassicScriptTarget,MainDocumentClassicSourceFailureWork,@@ -61,23 +61,23 @@ impl MainParserBlockingClassicScriptCompletionAction {#[derive(Clone)]pub(super) struct MainParserBlockingClassicScriptExecutionTarget {- parser_insertion_controller: Option<ParserInsertionController>,+ parser_bridge: Option<ParserConnectedScriptBridge>,completion_target: MainDocumentClassicScriptTarget,}impl MainParserBlockingClassicScriptExecutionTarget {pub(super) fn new(- parser_insertion_controller: Option<ParserInsertionController>,+ parser_bridge: Option<ParserConnectedScriptBridge>,completion_target: MainDocumentClassicScriptTarget,) -> Self {Self {- parser_insertion_controller,+ parser_bridge,completion_target,}}- pub(super) fn parser_insertion_controller(&self) -> Option<ParserInsertionController> {- self.parser_insertion_controller.clone()+ pub(super) fn parser_bridge(&self) -> Option<ParserConnectedScriptBridge> {+ self.parser_bridge.clone()}pub(super) fn completion_target(&self) -> MainDocumentClassicScriptTarget {@@ -94,15 +94,12 @@ pub(super) fn main_parser_blocking_ready_action(}pub(super) fn main_parser_blocking_begin_execution_action(- parser_insertion_controller: Option<ParserInsertionController>,+ parser_bridge: Option<ParserConnectedScriptBridge>,completion_target: MainDocumentClassicScriptTarget,action: ParserPendingClassicScriptBeginExecutionAction,) -> MainParserBlockingClassicScriptExecutionEntry {ParserClassicScriptBeginExecutionAction::from_pending_begin_execution_action(- MainParserBlockingClassicScriptExecutionTarget::new(- parser_insertion_controller,- completion_target,- ),+ MainParserBlockingClassicScriptExecutionTarget::new(parser_bridge, completion_target),action,)}diff --git a/moli-renderer-v8/src/runtime/phase_one/parser_turn.rs b/moli-renderer-v8/src/runtime/phase_one/parser_turn.rsindex 21b7e53d8..8babe5985 100644--- a/moli-renderer-v8/src/runtime/phase_one/parser_turn.rs+++ b/moli-renderer-v8/src/runtime/phase_one/parser_turn.rs@@ -19,7 +19,8 @@ use super::*;use crate::document_runtime::parser_script_preparation_failure_page_owned_work;use crate::dom::native::{Attribute, DomMutationEffects, NativeNodeId};use crate::live_document_parser::{- LiveDocumentParserOwner, LiveDocumentParserStepOutcome, ParserSuspensionCause,+ DocumentParserFinishRequestState, LiveDocumentParserOwner, LiveDocumentParserStepOutcome,+ ParserSuspensionCause,};use crate::parser::{ParserDomMutation, ParserDomMutationConsumer, ParserDomReadConsumer,@@ -553,10 +554,7 @@ impl<'loader, 'state> ParserDriver<'loader, 'state> {{if self.parser_session.input_is_empty() {if *self.input_closed {- return Ok(self.finish_main_parser_or_defer_borrowed_stream(- page_vm,- parser_document_owner,- ));+ return Ok(self.request_or_finish_main_parser(page_vm, parser_document_owner));}return Ok(OwnerStepProgress::NeedMoreInput);}@@ -680,7 +678,7 @@ impl<'loader, 'state> ParserDriver<'loader, 'state> {*parser_step_ready = false;let progress = if self.parser_session.input_is_empty() {if *self.input_closed {- self.finish_main_parser_or_defer_borrowed_stream(page_vm, parser_document_owner)+ self.request_or_finish_main_parser(page_vm, parser_document_owner)} else {OwnerStepProgress::NeedMoreInput}@@ -1305,27 +1303,37 @@ impl<'loader, 'state> ParserDriver<'loader, 'state> {outcome}- fn finish_main_parser_or_defer_borrowed_stream(+ fn request_or_finish_main_parser(&mut self,page_vm: &mut PageVm,parser_document_owner: crate::frame_owner_model::FrameDocumentTaskOwner,) -> OwnerStepProgress {- if !self.parser_session.has_exclusive_stream_handle() {- // A document.write recovery turn can drive this same main stream- // to EOF while its temporary ParserInsertionController is still- // live on the Page-task stack. EOF is final, but destroying the- // stream is only valid after that stack has unwound. Cross the- // stable scheduler boundary once; the selected continuation then- // re-enters this sole parser runtime with exclusive ownership.+ if self.parser_session.finish_request_state()+ == DocumentParserFinishRequestState::NotRequested+ {+ // Low-level fixtures can close their input flag directly. The+ // production input boundary records this before pumping begins.+ self.parser_session.request_finish();+ }+ if self.parser_session.finish_request_state() == DocumentParserFinishRequestState::Delayed {+ // A parser-connected script, suspension, or reentrant pump kept+ // work active after EOF was requested. Preserve that historical+ // fact even after the stack unwinds and require the exact+ // phase-one continuation to admit finalization.assert!(page_vm.vm().document_runtime.request_main_parser_continuation_if_active(),- "main parser EOF with a borrowed stream requires an active continuation route"+ "main parser EOF requires an active phase-one continuation route");return OwnerStepProgress::BlockedOnPageTask;}+ debug_assert!(matches!(+ self.parser_session.finish_request_state(),+ DocumentParserFinishRequestState::Requested+ | DocumentParserFinishRequestState::Admitted+ ));self.finish_main_parser(page_vm, parser_document_owner);OwnerStepProgress::AdvancePhase}diff --git a/moli-renderer-v8/src/runtime/phase_one/state.rs b/moli-renderer-v8/src/runtime/phase_one/state.rsindex c70916171..54d48526d 100644--- a/moli-renderer-v8/src/runtime/phase_one/state.rs+++ b/moli-renderer-v8/src/runtime/phase_one/state.rs@@ -39,6 +39,14 @@ impl ParseTimeDriverState {input_closed: false,}}++ pub(super) fn close_input(&mut self) {+ if self.input_closed {+ return;+ }+ self.parser_session.request_finish();+ self.input_closed = true;+ }}#[derive(Debug, Clone, Copy, PartialEq, Eq)]@@ -225,6 +233,10 @@ impl ConcurrentParseTimeRuntime {{return false;}+ let _ = self+ .state+ .parser_session+ .admit_delayed_finish_continuation();self.owner = ParseTimeOwner::Parser;self.parser_step_ready = true;self.pending_parsing_blocking_wait = PendingParsingBlockingWait::None;diff --git a/moli-renderer-v8/src/runtime/phase_one/streaming.rs b/moli-renderer-v8/src/runtime/phase_one/streaming.rsindex edb798a3b..045693ed4 100644--- a/moli-renderer-v8/src/runtime/phase_one/streaming.rs+++ b/moli-renderer-v8/src/runtime/phase_one/streaming.rs@@ -551,7 +551,7 @@ impl ConcurrentParseTimeRuntime {}pub(super) fn close_streaming_html_input(&mut self) {- self.state.input_closed = true;+ self.state.close_input();}pub(super) async fn continue_streaming_creation_on_execution_context(diff --git a/moli-renderer-v8/src/script_vm.rs b/moli-renderer-v8/src/script_vm.rsindex fe06c76d0..dae33cfba 100644--- a/moli-renderer-v8/src/script_vm.rs+++ b/moli-renderer-v8/src/script_vm.rs@@ -5810,7 +5810,7 @@ impl ScriptVm {.set_current_script_context(CurrentScriptContextSpec {handle: run_input.current_script,parser_write_insertion_point_active: run_input.parser_write_insertion_point_active,- parser_insertion_controller: None,+ parser_bridge: None,});let document_owner_before_run =self.current_main_document_task_owner().ok_or_else(|| {@@ -7932,12 +7932,12 @@ impl ScriptVm {);}};- let parser_insertion_controller = match (+ let parser_bridge = match (run_input.current_script,run_input.parser_write_insertion_point_active,- execution_context.parser_insertion_controller(),+ execution_context.parser_bridge(),) {- (Some(_), true, Some(controller)) => Some(controller.clone()),+ (Some(_), true, Some(bridge)) => Some(bridge.clone()),_ => None,};// XML parser-blocking scripts have a currentScript and use the same@@ -7945,12 +7945,12 @@ impl ScriptVm {// Absence of a controller therefore means document.write is inactive;// it must not suppress otherwise valid XHTML/SVG script execution.let parser_write_insertion_point_active =- run_input.parser_write_insertion_point_active && parser_insertion_controller.is_some();+ run_input.parser_write_insertion_point_active && parser_bridge.is_some();self.document_runtime.set_current_script_context(CurrentScriptContextSpec {handle: run_input.current_script,parser_write_insertion_point_active,- parser_insertion_controller,+ parser_bridge,});let document_owner_before_run = self.current_main_document_task_owner()@@ -8066,7 +8066,7 @@ impl ScriptVm {.set_current_script_context(CurrentScriptContextSpec {handle: run_input.current_script,parser_write_insertion_point_active: run_input.parser_write_insertion_point_active,- parser_insertion_controller: None,+ parser_bridge: None,});let result = self.execute_prepared_script_run_body(script, run_input.body)diff --git a/moli-renderer-v8/src/script_vm/main_parser_classic_completion.rs b/moli-renderer-v8/src/script_vm/main_parser_classic_completion.rsindex 5f2898efd..ebef2e55a 100644--- a/moli-renderer-v8/src/script_vm/main_parser_classic_completion.rs+++ b/moli-renderer-v8/src/script_vm/main_parser_classic_completion.rs@@ -87,17 +87,16 @@ impl ScriptVm {let mut application = ParserOwnedClassicScriptCompletionApplication::default();application.note_completion_applied(evaluation);let terminal_activity = if let Some(task) = script_element_event {- let _parser_script_nesting = execution_context- .is_parser_blocking()- .then(|| self.document_runtime.enter_parser_script_nesting());- let parser_insertion_controller =- execution_context.parser_insertion_controller().cloned();+ let parser_bridge = execution_context.parser_bridge().cloned();self.document_runtime.set_current_script_context(CurrentScriptContextSpec {handle: None,- parser_write_insertion_point_active: parser_insertion_controller.is_some(),- parser_insertion_controller,+ parser_write_insertion_point_active: parser_bridge.is_some(),+ parser_bridge,});+ let _parser_script_nesting = execution_context+ .is_parser_blocking()+ .then(|| self.document_runtime.enter_parser_script_nesting());let dispatch = self.dispatch_script_event_body(&task);self.document_runtime.clear_current_script_handle();match dispatch {diff --git a/moli-renderer-v8/src/script_vm/parser_owned_classic.rs b/moli-renderer-v8/src/script_vm/parser_owned_classic.rsindex de6c046f0..19fd94c2b 100644--- a/moli-renderer-v8/src/script_vm/parser_owned_classic.rs+++ b/moli-renderer-v8/src/script_vm/parser_owned_classic.rs@@ -6,7 +6,7 @@//! "finished" from a script handle, an event, or a compatibility boolean.use super::{PreparedScriptBodyActivity, ScriptTerminalBodyActivity};-use crate::{document_runtime::ParserInsertionController, host::ScriptEventTask};+use crate::{document_runtime::ParserConnectedScriptBridge, host::ScriptEventTask};#[derive(Debug)]pub(crate) struct ParserOwnedClassicScriptExecutionError {@@ -79,7 +79,7 @@ impl ParserOwnedClassicScriptExecutionReport {#[derive(Clone, Debug)]pub(crate) enum ParserOwnedClassicScriptExecutionContext {ParserBlocking {- insertion_controller: Option<ParserInsertionController>,+ parser_bridge: Option<ParserConnectedScriptBridge>,},Deferred,}@@ -89,11 +89,9 @@ impl ParserOwnedClassicScriptExecutionContext {matches!(self, Self::ParserBlocking { .. })}- pub(crate) fn parser_insertion_controller(&self) -> Option<&ParserInsertionController> {+ pub(crate) fn parser_bridge(&self) -> Option<&ParserConnectedScriptBridge> {match self {- Self::ParserBlocking {- insertion_controller,- } => insertion_controller.as_ref(),+ Self::ParserBlocking { parser_bridge } => parser_bridge.as_ref(),Self::Deferred => None,}}@@ -119,12 +117,12 @@ impl ParserOwnedClassicScriptCompletion {}pub(crate) fn parser_blocking_source_failure(- parser_insertion_controller: Option<ParserInsertionController>,+ parser_bridge: Option<ParserConnectedScriptBridge>,script_element_event: Option<ScriptEventTask>,) -> Self {Self {execution_context: ParserOwnedClassicScriptExecutionContext::ParserBlocking {- insertion_controller: parser_insertion_controller,+ parser_bridge,},script_element_event,evaluation: ParserOwnedClassicScriptEvaluationSettlement::NotSettled,diff --git a/moli-renderer-v8/src/script_vm/tests/dom_xhr/misc.rs b/moli-renderer-v8/src/script_vm/tests/dom_xhr/misc.rsindex 68804f991..b7704c496 100644--- a/moli-renderer-v8/src/script_vm/tests/dom_xhr/misc.rs+++ b/moli-renderer-v8/src/script_vm/tests/dom_xhr/misc.rs@@ -171,7 +171,7 @@ fn current_script_is_null_while_script_remains_in_shadow_tree() {.set_current_script_context(CurrentScriptContextSpec {handle: Some(outer),parser_write_insertion_point_active: false,- parser_insertion_controller: None,+ parser_bridge: None,});vm.exec(r#"@@ -220,7 +220,7 @@ fn current_script_is_null_while_script_remains_in_shadow_tree() {.set_current_script_context(CurrentScriptContextSpec {handle: Some(script),parser_write_insertion_point_active: false,- parser_insertion_controller: None,+ parser_bridge: None,});assert_eq!(vm.eval("String(document.currentScript)")@@ -235,7 +235,7 @@ fn current_script_is_null_while_script_remains_in_shadow_tree() {.set_current_script_context(CurrentScriptContextSpec {handle: Some(script),parser_write_insertion_point_active: false,- parser_insertion_controller: None,+ parser_bridge: None,});assert_eq!(vm.eval("document.currentScript && document.currentScript.id")