Struct WebUiProtocol 

pub struct WebUiProtocol {
    pub fragments: HashMap<String, FragmentList>,
    pub tokens: Vec<String>,
    pub components: HashMap<String, ComponentData>,
    pub css_strategy: i32,
    pub initial_state_strategy: i32,
    pub module_preloads: Vec<String>,
    pub component_render_css: String,
    pub style_closures: HashMap<String, ComponentStyleClosure>,
    pub style_chunks: Vec<StyleChunk>,
    pub component_asset_style_preloads: Vec<ComponentAssetStylePreload>,
}

Root protocol containing all fragment records and build metadata.

Fields

fragments: HashMap<String, FragmentList>

tokens: Vec<String>

Sorted, deduplicated CSS custom property names used across all components and entry page styles (e.g., “colorBrandBackground”, “spacingMedium”). Only usage via var(–name) is included; local definitions are excluded.

components: HashMap<String, ComponentData>

Per-component data keyed by tag name (f-template + CSS).

css_strategy: i32

Build-wide CSS delivery strategy. Determines how compiled component resources are installed in each CSS tree.

initial_state_strategy: i32

Whether initial SSR metadata contains full state or WebUI component projection. Partial-navigation state remains component-driven.

module_preloads: Vec<String>

Ready-to-write <link rel="modulepreload"> hrefs for the shared chunks that the page’s critical module entries statically import, in the exact order they must be emitted (largest chunk first).

These chunks are named only inside the entry’s own bytes, so the browser’s preload scanner cannot discover them until it has downloaded and parsed the entry. Emitting them as hints removes that serialization.

Order is load-bearing: preloads are issued in document order over one connection, so a small chunk ahead of a large one delays the long pole. The compiler resolves and sorts these at build time so the handler writes them verbatim with no per-request work.

component_render_css: String

Build-generated document-level rules for component rendering policies. Empty when no component opts into lazy rendering.

style_closures: HashMap<String, ComponentStyleClosure>

Ordered, deduplicated component style resource tags for each Document or component-root CSS tree entry point.

style_chunks: Vec<StyleChunk>

Bundled stylesheets in global cascade order. Empty unless the build enabled CSS bundling, in which case every component that owns a style resource belongs to exactly one chunk and handlers deliver chunks instead of individual component resources.

component_asset_style_preloads: Vec<ComponentAssetStylePreload>

Build-generated eager metadata for static component asset roots.

Entries are sorted by root tag. Builds without component assets omit the field from the wire.

Implementations

impl WebUiProtocol

pub fn css_strategy(&self) -> CssStrategy

Returns the enum value of css_strategy, or the default if the field is set to an invalid enum value.

pub fn set_css_strategy(&mut self, value: CssStrategy)

Sets css_strategy to the provided enum value.

pub fn initial_state_strategy(&self) -> InitialStateStrategy

Returns the enum value of initial_state_strategy, or the default if the field is set to an invalid enum value.

pub fn set_initial_state_strategy(&mut self, value: InitialStateStrategy)

Sets initial_state_strategy to the provided enum value.

impl WebUiProtocol

pub fn component_uses_shadow_dom(&self, tag_name: &str) -> bool

Return whether a component authored a declarative Shadow DOM root.

pub fn component_style_resource(&self, tag_name: &str) -> Option<&str>

Return the stored style resource for a component.

Link protocols identify a resource by css_href; Style and Module protocols retain the compiled CSS bytes. An empty field means that the component has no paired style resource.

pub fn style_closure(&self, root: &str) -> Option<&[String]>

Return a precomputed style closure for root.

pub fn populate_style_closures(&mut self, entry_fragments: &[&str])

Precompute ordered style-resource closures for entry fragments and every compiled component root.

Traversal is iterative, follows source order, stops at Shadow children and route activation edges, and deduplicates resources at first discovery. Matched route roots install their own stored closures.

pub fn style_chunk_resource(&self, chunk: u32) -> Option<(&str, &str)>

Return the delivered style resource for a bundled chunk index.

Mirrors Self::component_style_resource: Link protocols identify a chunk by css_href, Style and Module protocols carry the concatenated CSS bytes.

pub fn style_chunk_members(&self, chunk: u32) -> Option<&[String]>

Return the component tags merged into chunk, in cascade order.

pub fn style_chunk_index(&self) -> HashMap<&str, u32>

Map every component whose stylesheet a bundled chunk already ships to that chunk’s index.

This is the single definition of “already covered by a chunk”, and every delivery path must agree on it. A closure carries style_chunks only when the bundler treated it as a root; other closures still list their members individually, and delivering those members verbatim in a bundled build re-ships bytes the covering chunk already contains. Resolving a member through this map instead keeps each closure self-sufficient, so correctness never depends on which closure happens to install first.

Empty for unbundled builds. Build it once per render: it allocates.

pub fn style_closure_chunks(&self, root: &str) -> Option<&[u32]>

Return the bundled chunk indices for root, in cascade order.

Empty when the build did not bundle CSS, in which case callers deliver Self::style_closure component resources individually.

pub fn style_closure_unit_count(closure: &ComponentStyleClosure) -> usize

Number of delivery units closure walks, in cascade order.

A closure the bundler treated as a root ships one unit per chunk; every other closure ships one unit per member.

pub fn style_closure_unit<'a>( &'a self, closure: &'a ComponentStyleClosure, chunk_index: &HashMap<&str, u32>, position: usize, ) -> Option<StyleClosureUnit<'a>>

Resolve one position of closure to the resource that delivers it.

This is the single walk shared by every delivery path, so all of them agree on Self::style_chunk_index’s definition of “already covered by a chunk”. A closure that was not a bundler root uses a chunk only when the chunk’s complete ordered membership is present; otherwise it falls back to the individual component resource. chunk_index must come from that accessor; pass an empty map for an unbundled protocol.

Returns None only when position is out of range. A unit whose resource is None names a resource the protocol does not hold, which callers report or skip according to their own delivery contract.

pub fn new(fragments: WebUIFragmentRecords) -> Self

Create a protocol from fragment records with no CSS tokens.

pub fn with_tokens(fragments: WebUIFragmentRecords, tokens: Vec<String>) -> Self

Create a protocol from fragment records with CSS tokens.

impl WebUiProtocol

pub fn to_json_pretty(&self) -> Result<String, Error>

Serialize protocol to pretty JSON (for debug/inspect output only).

pub fn to_protobuf(&self) -> Result<Vec<u8>>

Serialize protocol to protobuf binary format.

pub fn from_protobuf(bytes: &[u8]) -> Result<Self>

Deserialize protocol from protobuf binary bytes with validation.

pub fn from_protobuf_file<P: AsRef<Path>>(path: P) -> Result<Self>

Read and deserialize a protobuf file with validation.

pub fn to_protobuf_file<P: AsRef<Path>>(&self, path: P) -> Result<()>

Write protocol to a protobuf file.

Trait Implementations

impl Clone for WebUiProtocol

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for WebUiProtocol

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for WebUiProtocol

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for WebUiProtocol

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Message for WebUiProtocol

fn encoded_len(&self) -> usize

Returns the encoded length of the message without a length delimiter.

fn clear(&mut self)

Clears the message, resetting all fields to their default.

fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>

where Self: Sized,

Encodes the message to a buffer.

fn encode_to_vec(&self) -> Vec<u8>

where Self: Sized,

Encodes the message to a newly allocated buffer.

fn encode_length_delimited( &self, buf: &mut impl BufMut, ) -> Result<(), EncodeError>

where Self: Sized,

Encodes the message with a length-delimiter to a buffer.

fn encode_length_delimited_to_vec(&self) -> Vec<u8>

where Self: Sized,

Encodes the message with a length-delimiter to a newly allocated buffer.

fn decode(buf: impl Buf) -> Result<Self, DecodeError>

where Self: Default,

Decodes an instance of the message from a buffer.

fn decode_length_delimited(buf: impl Buf) -> Result<Self, DecodeError>

where Self: Default,

Decodes a length-delimited instance of the message from the buffer.

fn merge(&mut self, buf: impl Buf) -> Result<(), DecodeError>

where Self: Sized,

Decodes an instance of the message from a buffer, and merges it into self.

fn merge_length_delimited(&mut self, buf: impl Buf) -> Result<(), DecodeError>

where Self: Sized,

Decodes a length-delimited instance of the message from buffer, and merges it into self.

impl PartialEq for WebUiProtocol

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for WebUiProtocol

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for WebUiProtocol