Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

fix(layout): isolate PDF print layout from interactive snapshots

ldm04b24590ce631
diff --git a/moli-layout/src/error.rs b/moli-layout/src/error.rs
index 930088c5e..53f7380c8 100644
--- a/moli-layout/src/error.rs
+++ b/moli-layout/src/error.rs
@@ -5,7 +5,7 @@ use thiserror::Error;
pub enum LayoutError {
/// Geometry and input consume published layout and cannot create it.
#[error(
- "no published layout is available for the current document; call Page.captureScreenshot or Page.printToPDF, or start Page.startScreencast and wait for a frame, then retry. Geometry queries and input do not create layout"
+ "no published layout is available for the current document; call Page.captureScreenshot, or start Page.startScreencast and wait for a frame, then retry. Geometry queries and input do not create layout"
)]
NoLayoutSnapshot,
/// A geometry consumer forced layout before the Document had an element root.
diff --git a/moli-layout/src/layout_tree/query.rs b/moli-layout/src/layout_tree/query.rs
index a9edb597a..891e53446 100644
--- a/moli-layout/src/layout_tree/query.rs
+++ b/moli-layout/src/layout_tree/query.rs
@@ -189,7 +189,7 @@ pub trait GeometryProvider {
/// Answers a batch from the provider's latest layout state.
///
/// Reading never computes layout. Real-layout providers require a tree
- /// published by a screenshot, screencast frame, or PDF output.
+ /// published by a screenshot or screencast frame.
fn answer(
&mut self,
queries: &LayoutQueryBatch<Self::NodeId>,
diff --git a/moli-page-types/src/layout.rs b/moli-page-types/src/layout.rs
index 8e9301933..c8047eede 100644
--- a/moli-page-types/src/layout.rs
+++ b/moli-page-types/src/layout.rs
@@ -6,7 +6,8 @@ pub enum LayoutPolicy {
/// such as renderer screenshots that require a real layout backend.
#[default]
Mock,
- /// Only screenshot, screencast, and PDF output build and publish layout.
+ /// Only screenshot, screencast, and PDF output build layout.
+ /// Screenshots and screencasts publish layout; print projections are temporary.
/// Geometry queries and input read the last published layout, if any.
OnDemand,
}
diff --git a/moli-protocol-server/src/protocol_server/tests/classic.rs b/moli-protocol-server/src/protocol_server/tests/classic.rs
index 50f602f52..afe032408 100644
--- a/moli-protocol-server/src/protocol_server/tests/classic.rs
+++ b/moli-protocol-server/src/protocol_server/tests/classic.rs
@@ -11274,16 +11274,19 @@ async fn webdriver_classic_element_click_uses_shared_dom_geometry_and_input() {
)
.await;
assert_eq!(cold_status, StatusCode::INTERNAL_SERVER_ERROR);
- for command in [
- "Page.captureScreenshot",
- "Page.printToPDF",
- "Page.startScreencast",
- ] {
+ for command in ["Page.captureScreenshot", "Page.startScreencast"] {
assert!(
cold["value"]["message"].as_str().unwrap().contains(command),
"{cold}"
);
}
+ assert!(
+ !cold["value"]["message"]
+ .as_str()
+ .unwrap()
+ .contains("Page.printToPDF"),
+ "{cold}"
+ );
classic_capture_layout(app.clone(), session_id).await;
let clicked = classic_request_json(
diff --git a/moli-protocol/src/domains/input/tests/mouse_snapshot.rs b/moli-protocol/src/domains/input/tests/mouse_snapshot.rs
index 27bbd5ebd..dab9a7510 100644
--- a/moli-protocol/src/domains/input/tests/mouse_snapshot.rs
+++ b/moli-protocol/src/domains/input/tests/mouse_snapshot.rs
@@ -50,12 +50,12 @@ async fn cdp_geometry_and_mouse_require_explicit_layout_publication() {
.expect("missing-layout error");
for command in [
"Page.captureScreenshot",
- "Page.printToPDF",
"Page.startScreencast",
"wait for a frame",
] {
assert!(message.contains(command), "{cold}");
}
+ assert!(!message.contains("Page.printToPDF"), "{cold}");
}
ctx.process_async(json!({"id":719,"method":"Page.captureScreenshot"}))
.await;
diff --git a/moli-protocol/src/domains/page/tests/capture.rs b/moli-protocol/src/domains/page/tests/capture.rs
index 381970da1..cdde9324f 100644
--- a/moli-protocol/src/domains/page/tests/capture.rs
+++ b/moli-protocol/src/domains/page/tests/capture.rs
@@ -513,7 +513,7 @@ fn mhtml_snapshot_base64_encodes_html_and_sanitizes_header_url() {
assert!(!mhtml.contains(html));
}
#[tokio::test(flavor = "multi_thread")]
-async fn print_to_pdf_returns_base64_pdf_and_publishes_print_geometry() {
+async fn print_to_pdf_returns_base64_pdf_without_publishing_interactive_geometry() {
let mut ctx = TestContext::new();
install_active_screenshot_page(
&mut ctx,
@@ -546,8 +546,28 @@ async fn print_to_pdf_returns_base64_pdf_and_publishes_print_geometry() {
ctx.process_async(query.clone()).await;
assert_eq!(
take_response_by_id(&mut ctx, 1111)["result"]["result"]["value"],
- 80
+ 0
);
+ for (method, params) in [
+ ("Page.getLayoutMetrics", json!({})),
+ (
+ "Input.dispatchMouseEvent",
+ json!({"type":"mousePressed","x":20,"y":20,"button":"left"}),
+ ),
+ ] {
+ ctx.process_async(json!({
+ "id": 1113,
+ "method": method,
+ "sessionId": "SID-PDF-BASE64",
+ "params": params
+ }))
+ .await;
+ let response = take_response_by_id(&mut ctx, 1113);
+ assert_eq!(response["error"]["code"], -32000, "{response}");
+ let message = response["error"]["message"].as_str().unwrap();
+ assert!(message.contains("Page.captureScreenshot"), "{response}");
+ assert!(!message.contains("Page.printToPDF"), "{response}");
+ }
ctx.capture_fixture_layout(Some("SID-PDF-BASE64")).await;
ctx.process_async(query).await;
assert_eq!(
diff --git a/moli-renderer-v8/src/native_bridge/context_host/layout.rs b/moli-renderer-v8/src/native_bridge/context_host/layout.rs
index 1e0b5fbc0..9e890d5d5 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/layout.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/layout.rs
@@ -206,12 +206,11 @@ impl JsContextHost {
.inferred_frame_style_viewport_cache_observability()
}
- pub(crate) fn with_fresh_layout_pass_for_document<T>(
+ pub(crate) fn build_layout_pass_for_document(
&self,
document: DomHandle,
request: LayoutPassRequest,
- consume: impl FnOnce(&mut LayoutPassResult<DomHandle>) -> Result<T, LayoutError>,
- ) -> Result<Option<T>, LayoutError> {
+ ) -> Result<Option<LayoutPassResult<DomHandle>>, LayoutError> {
let Some(root) = self
.dom_host()
.dom()
@@ -219,15 +218,13 @@ impl JsContextHost {
else {
return Ok(None);
};
- let pass_viewport = request.viewport;
let _active = ActiveLayoutPass::enter(&self.layout_pass_active)?;
- let mut pass = {
+ let pass = {
let mut state = self.document_layout_state.borrow_mut();
state.retain_live_embedded_document_services(|candidate| {
self.child_browsing_context_host_for_document_handle(candidate)
.is_some()
});
- state.retain_live_frame_viewports(|frame| self.child_browsing_context_is_live(frame));
state.with_services_for_document(
document,
self.document_handle(),
@@ -283,8 +280,16 @@ impl JsContextHost {
);
}
pass.validate_retention_budget()?;
- let consumed = consume(&mut pass)?;
+ Ok(Some(pass))
+ }
+
+ pub(crate) fn publish_layout_pass_for_document(
+ &self,
+ document: DomHandle,
+ pass: LayoutPassResult<DomHandle>,
+ ) {
let metrics = pass.metrics;
+ let pass_viewport = pass.viewport;
let frame_viewports = self
.child_browsing_context_handles_in_document_order()
.into_iter()
@@ -310,6 +315,7 @@ impl JsContextHost {
let tree = pass.into_tree();
let frame_viewports_changed = {
let mut state = self.document_layout_state.borrow_mut();
+ state.retain_live_frame_viewports(|frame| self.child_browsing_context_is_live(frame));
state.publish_latest_layout(document, tree);
state.update_frame_viewports(frame_viewports)
};
@@ -320,7 +326,6 @@ impl JsContextHost {
self.last_layout_pass_metrics.set(Some(metrics));
self.layout_snapshot_cache_publishes
.set(self.layout_snapshot_cache_publishes.get().saturating_add(1));
- Ok(Some(consumed))
}
pub(crate) fn answer_layout_for_document(
diff --git a/moli-renderer-v8/src/native_bridge/context_host/layout_snapshot.rs b/moli-renderer-v8/src/native_bridge/context_host/layout_snapshot.rs
index 07796eda5..7edab2c7a 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/layout_snapshot.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/layout_snapshot.rs
@@ -12,7 +12,8 @@ struct LatestFrozenLayout {
/// This owns exactly one recursively frozen snapshot. It has no separately
/// keyed child tree, working layout world, source index, hit-test index, Taffy
/// cache, style borrow, pass diagnostics, paint snapshot, timer, or invalidation
-/// policy. Only explicit visual output replaces this published layout.
+/// policy. Only screenshots and screencast frames replace this published layout;
+/// print projections are temporary and never enter this cache.
#[derive(Default)]
pub(super) struct LatestLayoutTreeCache {
latest: Option<LatestFrozenLayout>,
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/rendering_update.rs b/moli-renderer-v8/src/runtime/page_vm/tests/rendering_update.rs
index f0da31e15..750ef75bf 100644
--- a/moli-renderer-v8/src/runtime/page_vm/tests/rendering_update.rs
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/rendering_update.rs
@@ -1,5 +1,6 @@
use super::*;
+mod print;
mod transform_precision;
use base64::Engine as _;
@@ -170,9 +171,10 @@ document.body.innerHTML = '<div id="target"></div><div id="pass-through"></div><
let viewport = moli_layout::LayoutViewport::new(320, 200, 1.0);
let error = moli_layout::GeometryProvider::answer(page_vm.vm_mut(), &batch).unwrap_err();
assert_eq!(error, moli_layout::LayoutError::NoLayoutSnapshot);
- for command in ["Page.captureScreenshot", "Page.printToPDF", "Page.startScreencast"] {
+ for command in ["Page.captureScreenshot", "Page.startScreencast"] {
assert!(error.to_string().contains(command));
}
+ assert!(!error.to_string().contains("Page.printToPDF"));
assert_eq!(page_vm.vm().layout_pass_observability_for_test().1, before.1);
page_vm.vm_mut().screenshot_layout_snapshot(viewport)?.expect("initial screenshot layout");
let first = moli_layout::GeometryProvider::answer(
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/rendering_update/print.rs b/moli-renderer-v8/src/runtime/page_vm/tests/rendering_update/print.rs
new file mode 100644
index 000000000..75a254744
--- /dev/null
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/rendering_update/print.rs
@@ -0,0 +1,93 @@
+use super::*;
+use crate::runtime::{
+ RendererCaptureScreenshotReply, RendererCaptureScreenshotRequest, RendererScreenshotPurpose,
+};
+
+#[tokio::test(flavor = "current_thread")]
+async fn print_capture_preserves_published_geometry_frame_viewports_and_mouse_targets() {
+ run_page_vm_async_test(async move {
+ let loader =
+ crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let mut page_vm = test_page_vm_with_loader_and_document_url(
+ &loader,
+ Vec::new(),
+ Url::parse("https://example.com/print-layout.html")?,
+ );
+ page_vm.set_viewport_surface(Some(crate::protocol_types::ViewportSurface {
+ inner_width: 320,
+ inner_height: 100,
+ ..Default::default()
+ }))?;
+ page_vm.vm_mut().eval(
+ r#"
+document.head.innerHTML = `<style>
+html,body { margin:0; background:white }
+#target,iframe { position:absolute; left:0; top:0; width:40px; height:40px; border:0 }
+#target { background:red }
+iframe { top:50px }
+.changed #target,.changed iframe { width:60px }
+@media print {
+ #target,iframe { left:160px; width:80px !important }
+ #target { background:lime }
+}
+</style>`;
+document.body.innerHTML = '<div id=target></div><iframe id=frame></iframe>';
+const child = frame.contentDocument;
+child.documentElement.style.cssText = 'margin:0';
+child.body.style.cssText = 'margin:0;background:blue;height:40px';
+globalThis.clicks = 0;
+target.onclick = () => clicks++;
+'installed'
+"#,
+ )?;
+ page_vm.vm_mut().sync_live_document_style_sources();
+ page_vm.capture_screenshot(RendererCaptureScreenshotRequest::viewport_png())?;
+ let geometry = "JSON.stringify([target.getBoundingClientRect().width,frame.getBoundingClientRect().width,frame.contentDocument.body.getBoundingClientRect().width,frame.contentWindow.innerWidth])";
+ assert_eq!(page_vm.vm_mut().eval(geometry)?, "[40,40,40,40]");
+ let before = page_vm.vm().layout_pass_observability_for_test();
+ let published_before = page_vm.vm().layout_snapshot_cache_observability_for_test().2;
+
+ // Restoring the screen media after printing must not rebuild the live
+ // DOM either: geometry continues to describe the earlier screenshot.
+ page_vm.vm_mut().eval("document.body.classList.add('changed')")?;
+ let RendererCaptureScreenshotReply::Captured(print) = page_vm.capture_screenshot(
+ RendererCaptureScreenshotRequest {
+ purpose: RendererScreenshotPurpose::Print { print_background: true },
+ ..RendererCaptureScreenshotRequest::viewport_png()
+ },
+ )? else {
+ panic!("print capture should produce an image");
+ };
+ let raster = moli_image::decode_png(&print.bytes)?;
+ let pixel = |x: usize, y: usize| {
+ let offset = (y * raster.width as usize + x) * 4;
+ &raster.rgba[offset..offset + 4]
+ };
+ assert_eq!(pixel(20, 20), [255, 255, 255, 255]);
+ assert_eq!(pixel(230, 20), [0, 255, 0, 255]);
+ assert_eq!(pixel(230, 70), [0, 0, 255, 255]);
+ assert_eq!(page_vm.vm_mut().eval("matchMedia('print').matches")?, "false");
+ assert_eq!(page_vm.vm_mut().eval(geometry)?, "[40,40,40,40]");
+ let after = page_vm.vm().layout_pass_observability_for_test();
+ assert_eq!(after.1, before.1 + 1, "printing must perform exactly one layout");
+ assert_eq!(after.3, before.3, "geometry keeps its published pass metrics");
+ assert_eq!(page_vm.vm().layout_snapshot_cache_observability_for_test().2, published_before);
+
+ for x in [20.0, 180.0] {
+ for (event, buttons) in [("mousedown", 1), ("mouseup", 0)] {
+ page_vm.vm_mut().dispatch_mouse_event_at_point(
+ x, 20.0, event, 0, Some(buttons), 0.0, 0.0,
+ )?;
+ }
+ }
+ assert_eq!(page_vm.vm_mut().eval("String(clicks)")?, "1");
+ assert_eq!(page_vm.vm().layout_pass_observability_for_test().1, after.1);
+
+ page_vm.capture_screenshot(RendererCaptureScreenshotRequest::viewport_png())?;
+ assert_eq!(page_vm.vm_mut().eval(geometry)?, "[60,60,60,60]");
+ assert_eq!(page_vm.vm().layout_snapshot_cache_observability_for_test().2, published_before + 1);
+ Ok::<_, anyhow::Error>(())
+ })
+ .await
+ .expect("print should preserve the interactive layout");
+}
diff --git a/moli-renderer-v8/src/script_vm.rs b/moli-renderer-v8/src/script_vm.rs
index 5ddf38bd5..43acc3f4c 100644
--- a/moli-renderer-v8/src/script_vm.rs
+++ b/moli-renderer-v8/src/script_vm.rs
@@ -2525,17 +2525,28 @@ impl ScriptVm {
// call.
self.reconcile_document_web_fonts_for_layout();
let requests_paint = request.requests_paint();
+ // Printing consumes a temporary projection. Screenshots and screencast
+ // frames publish geometry for input, observers and subsequent DOM reads.
+ let publishes_layout = request.reason != moli_layout::LayoutFlushReason::Print;
let (document, result) = {
let context_host = self._context_host.borrow();
let document = context_host.document_handle();
- let result =
- context_host.with_fresh_layout_pass_for_document(document, request, |pass| {
+ let result = context_host
+ .build_layout_pass_for_document(document, request)
+ .and_then(|pass| {
+ let Some(mut pass) = pass else {
+ return Ok(None);
+ };
let css_images = if requests_paint {
pass.css_image_references().to_vec()
} else {
Vec::new()
};
- consume(pass).map(|value| (value, css_images))
+ let value = consume(&mut pass)?;
+ if publishes_layout {
+ context_host.publish_layout_pass_for_document(document, pass);
+ }
+ Ok(Some((value, css_images)))
});
(document, result)
};
@@ -2545,7 +2556,8 @@ impl ScriptVm {
Err(error) => (Err(error), Vec::new()),
};
self.start_css_images_discovered_by_layout(css_images);
- if matches!(&result, Ok(Some(_)))
+ if publishes_layout
+ && matches!(&result, Ok(Some(_)))
&& let Err(error) = self.with_default_context_scope(|scope, runtime_ptr| {
crate::observer_runtime::queue_intersection_checks(scope, runtime_ptr);
crate::native_bridge::element::queue_revealed_lazy_image_loads(
diff --git a/moli-renderer-v8/src/script_vm/tests/element_click.rs b/moli-renderer-v8/src/script_vm/tests/element_click.rs
index eec5923a8..3bd3af5b4 100644
--- a/moli-renderer-v8/src/script_vm/tests/element_click.rs
+++ b/moli-renderer-v8/src/script_vm/tests/element_click.rs
@@ -13,13 +13,10 @@ fn native_element_click_requires_explicit_layout_without_building_it() {
let crate::runtime::RendererElementClickError::LayoutUnavailable(message) = error else {
panic!("expected missing-layout guidance, got {error:?}");
};
- for command in [
- "Page.captureScreenshot",
- "Page.printToPDF",
- "Page.startScreencast",
- ] {
+ for command in ["Page.captureScreenshot", "Page.startScreencast"] {
assert!(message.contains(command), "{message}");
}
+ assert!(!message.contains("Page.printToPDF"), "{message}");
assert_eq!(vm.layout_pass_observability_for_test().1, before);
publish_layout_for_test(&mut vm);
assert!(matches!(