🥮 mooncakes.io
README

mizchi/crater-renderer/vrt does not have a README file

#
ComputedStyleEntry

source
pub(all) struct ComputedStyleEntry {
  id : String
  index : Int
  display : String
  position : String
  visibility : String
  font_size : String
  font_family : String
  opacity : String
  z_index : String
  color : String
  background_color : String
} derive(Eq, Show)

Resolved computed style of one element, in the form page JS getComputedStyle reads. index is the pre-order (document-order) position in the render node tree — the same key collect_layout_boxes assigns to the parallel layout tree, so a JS DOM built in the same order can join geometry and computed style by index. Values are serialized as CSS strings (display "flex", color "rgb(255, 0, 0)", font-size "20px"). This is the node-tree analogue of collect_layout_boxes: the data layer a getComputedStyle bridge would inject.

#
CssMutation

source
pub(all) struct CssMutation {
  selector : String
  property : String
  action : CssMutationAction
} derive(Eq, 
Debug)

impl Show for CssMutation

#
CssMutation::is_paint_only

source
fn CssMutation::is_paint_only(self : CssMutation) -> Bool

Whether this mutation only affects paint (color/background/opacity/…), not box geometry — i.e. whether a branch carrying only such mutations can reuse the base layout.

#
CssMutationAction

source
pub(all) enum CssMutationAction {
  Remove
  Override(String)
} derive(Eq, 
Debug)

#
LayoutBox

source
pub(all) struct LayoutBox {
  id : String
  index : Int
  x : Double
  y : Double
  width : Double
  height : Double
} derive(Eq, Show)

Absolute geometry of one laid-out box, in the form page JS needs for getBoundingClientRect() / offsetWidth / offsetHeight. index is the pre-order (document-order) position in the layout tree — a stable key a JS DOM built in the same order can match. The crater layout tree already stores absolute viewport coordinates, so x/y are left/top directly.

#
PreparedVrtPage

source

#
RenderSession

source

A reusable render "snapshot" for VRT branching. open parses + cascades + lays out + paints the base document once; each branch applies a CSS-mutation delta. A branch can either re-layout fully (branch_full, for geometry- affecting changes) or reuse the base layout (branch_reusing_layout, valid when the delta is paint-only) — the latter skips the dominant layout cost.

#
RenderSession::base_paint_tree

source

The base (unmutated) paint tree captured at open().

#
RenderSession::branch

source

Branch with automatic strategy: if every mutation is paint-only the base layout is reused (fast path); otherwise a full re-layout is performed. This is the convenient default — correct for any delta, fast for recolor/theme variants (the common VRT case).

#
RenderSession::branch_diff

source

Paint-tree diff of an auto-strategy branch against the base.

#
RenderSession::branch_full

source

Branch with a full re-layout (correct for any mutation, including ones that change box geometry). Re-cascades + re-lays-out + paints from scratch, reusing only the parsed document.

#
RenderSession::branch_full_diff

source

Paint-tree diff of a full-relayout branch against the base.

#
RenderSession::branch_reusing_layout

source

Branch reusing the base layout: re-cascade the mutated document but paint it against the base layout, skipping re-layout. Valid only when the mutation is paint-only (it changes paint properties — color, background, opacity, … — not box geometry); for such a delta the layout is identical, so the painted result equals branch_full at a fraction of the cost.

#
RenderSession::branch_reusing_layout_diff

source

Paint-tree diff of a layout-reusing (paint-only) branch against the base.

#
RenderSession::element_boxes

source
fn RenderSession::element_boxes(self : RenderSession) -> Array[LayoutBox]

Per-box geometry of the session's base render — the geometry page JS would observe via getBoundingClientRect on the initial layout.

#
RenderSession::element_computed_styles

source
fn RenderSession::element_computed_styles(self : RenderSession) -> Array[ComputedStyleEntry]

Per-element computed style of the session's base render — what page JS would observe via getComputedStyle on the initial render.

#
RenderSession::layout_bridge_init_js

source
fn RenderSession::layout_bridge_init_js(self : RenderSession) -> String

The bridge-injection JS for the session's base render — the layout geometry and resolved styles page JS would observe on the initial layout. A host that drives the JS realm (the browser shell over the native V8 runtime) evaluates this before running page scripts so DOM measurement reads crater's real layout. See layout_bridge_init_js.

#
RenderSession::open

source
fn RenderSession::open(html : String, viewport : 
Size[Double], external_css : Array[String]) -> RenderSession

Parse + cascade + layout + paint the base document once, recording the external text-measurement side effect so branches (and a restored session) reproduce it without a font engine.

#
RenderSession::open_with_recording

source

Restore a session from a previously recorded measurement set (e.g. one serialized to disk). The base is rendered by replaying measurements, so no font engine is required; branches then reuse the same recording. This is the portable side of the snapshot: capture once with open(), persist session.measurements, reproduce anywhere.

#
RenderSession::recorded_images

source

The recorded image intrinsic sizes; serialize with @renderer.serialize_image_intrinsic_recording.

#
RenderSession::recorded_measurements

source

The recorded text measurements; serialize with @renderer.serialize_text_metrics_recording.

#
RenderVariant

source
pub(all) struct RenderVariant {
  id : String
  mutations : Array[CssMutation]
} derive(Eq, 
Debug)

#
RenderVariantResult

source
pub(all) struct RenderVariantResult {
  id : String
  paint_tree : 
PaintNode
}

#
collect_computed_styles

source
fn collect_computed_styles(node : 
Node) -> Array[ComputedStyleEntry]

Flatten a render node tree into per-element computed style in document order. This is the parallel of collect_layout_boxes for the page-JS getComputedStyle bridge: the node tree carries the resolved @style.Style per element, and the indexes line up with the layout-box indexes so the two can be joined element-for-element.

#
collect_layout_boxes

source
fn collect_layout_boxes(layout : 
Layout) -> Array[LayoutBox]

Flatten a layout tree into per-box absolute geometry in document order. This is the data layer that connects crater's layout engine to page JS box measurement (the bridge would inject these and have getBoundingClientRect / offsetWidth / offsetHeight read them, keyed by index, instead of the inline-style heuristic the runtime uses today).

#
computed_style_by_id

source
fn computed_style_by_id(node : 
Node, id_fragment : String) -> ComputedStyleEntry?

The first element whose node id contains id_fragment, for getComputedStyle-by-element lookup.

#
diff_rendered_paint_trees

source
fn diff_rendered_paint_trees(baseline_html : String, current_html : String, viewport : 
Size[Double]) -> 
PaintTreeDiff

#
layout_box_by_id

source
fn layout_box_by_id(layout : 
Layout, id_fragment : String) -> LayoutBox?

The first box whose layout id contains id_fragment (e.g. an element id like "main#content" or "#sidebar"), for getElementById-style measurement.

#
layout_bridge_init_js

source
fn layout_bridge_init_js(boxes : Array[LayoutBox], styles : Array[ComputedStyleEntry]) -> String

Serialize the layout-box geometry index and the computed-style index into the JS the dynamic-rendering bridge injects into the page realm before page JS runs. It defines two globals as document-order arrays:

  • globalThis.__craterLayoutBoxes — {index, id, x, y, width, height}
  • globalThis.__craterComputedStyles — {index, id, display, position,visibility, fontSize, fontFamily, opacity, zIndex, color, backgroundColor}

Each entry carries both the pre-order index and the tag#id id string so the mock DOM can join an element to its real geometry / resolved style by id (unique when the element has an id attribute) or, failing that, by document-order index. With these present, getBoundingClientRect / offsetWidth / offsetHeight / getComputedStyle read crater's real layout instead of the inline-style heuristic. This is the JS payload half of step (1) "expose real layout to page JS" in docs/dynamic-rendering-js-bridge-design.md; the mock-DOM consumer lives in browser/native/js_v8/mock_dom_full.mbt.

#
prepare_external_css

source
fn prepare_external_css(external_css : Array[String]) -> 
PreparedExternalCss

#
prepare_vrt_page

source
fn prepare_vrt_page(html : String, viewport : 
Size[Double], external_css : Array[String]) -> PreparedVrtPage

#
prepare_vrt_page_with_prepared_external_css

source
fn prepare_vrt_page_with_prepared_external_css(html : String, viewport : 
Size[Double], external_css : 
PreparedExternalCss) -> PreparedVrtPage

#
render_html_batch_variants

source
fn render_html_batch_variants(html : String, viewport : 
Size[Double], variants : Array[RenderVariant]) -> Array[RenderVariantResult]

#
render_html_to_paint_tree

source
fn render_html_to_paint_tree(html : String, viewport : 
Size[Double]) -> 
PaintNode

#
render_html_to_paint_tree_json

source
fn render_html_to_paint_tree_json(html : String, viewport : 
Size[Double]) -> String

#
render_html_to_paint_tree_with_external_css

source
fn render_html_to_paint_tree_with_external_css(html : String, viewport : 
Size[Double], external_css : Array[String]) -> 
PaintNode

#
render_html_to_paint_tree_with_prepared_external_css

source
fn render_html_to_paint_tree_with_prepared_external_css(html : String, viewport : 
Size[Double], external_css : 
PreparedExternalCss) -> 
PaintNode

#
render_prepared_vrt_page_to_paint_tree

source
fn render_prepared_vrt_page_to_paint_tree(page : PreparedVrtPage) -> 
PaintNode

#
render_prepared_vrt_page_to_paint_tree_json

source
fn render_prepared_vrt_page_to_paint_tree_json(page : PreparedVrtPage) -> String

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io