Enum Patch 

pub enum Patch {
    Create {
        id: String,
        element_type: String,
        props: ResolvedProps,
    },
    SetProp {
        id: String,
        name: String,
        value: Value,
    },
    RemoveProp {
        id: String,
        name: String,
    },
    SetText {
        id: String,
        text: String,
    },
    Insert {
        parent_id: String,
        id: String,
        before_id: Option<String>,
    },
    Move {
        parent_id: String,
        id: String,
        before_id: Option<String>,
    },
    Remove {
        id: String,
    },
    Detach {
        id: String,
    },
    Attach {
        parent_id: String,
        id: String,
        before_id: Option<String>,
    },
}

Platform-agnostic patch operations for updating the UI.

Patches are the wire protocol between the Hypen engine and platform renderers (DOM, Canvas, iOS UIKit, Android Views). Every mutation to the UI tree is expressed as an ordered sequence of Patch values.

Serialization

Patches serialize to JSON with a "type" discriminator and camelCase field names for direct JavaScript consumption:

{"type": "create", "id": "1", "elementType": "Text", "props": {"0": "Hello"}}
{"type": "insert", "parentId": "root", "id": "1", "beforeId": null}

Node IDs

Node IDs are opaque string identifiers (currently compact integers like "1", "42"). Renderers must treat them as opaque — the format may change between versions. The special parent ID "root" refers to the renderer’s root container.

Ordering

Within a single render cycle, patches are ordered such that:

1. Create always precedes Insert for the same node
2. SetProp/SetText follow Create for new nodes
3. Remove is always the last operation for a given node
4. Insert/Move specify position via before_id (None = append)

Variants

Create

Create a new element node with initial properties.

The renderer should allocate a platform-native element and store it by id. The node is not yet visible — a subsequent Insert attaches it.

props is Arc<IndexMap<...>> so emitting a Create for an existing InstanceNode is an Arc clone rather than a deep copy of the map. Wire format is unchanged — the custom serde shim serializes the inner map directly without exposing the Arc.

Fields

id: String

Opaque node identifier

element_type: String

Element type name (e.g. "Text", "Column", "Button")

props: ResolvedProps

Initial properties. Key "0" is the positional text content.

SetProp

Update a single property on an existing node.

Fields

id: String

name: String

Property name (e.g. "color", "fontSize")

value: Value

New value

RemoveProp

Remove a property from an existing node (revert to default).

Fields

id: String

name: String

Property name to remove

SetText

Set the text content of a node.

Reserved for future use — not currently emitted by the engine. The reconciler represents text changes as SetProp { name: "0", ... } (the positional content slot), so no production code path constructs a SetText patch today. Renderers must still handle this variant for forward compatibility; removing it would break the wire format.

Fields

id: String

text: String

New text content

Insert

Insert a node as a child of parent_id.

If before_id is Some, insert before that sibling. If None, append.

Fields

parent_id: String

Parent node ID, or "root" for the root container

id: String

before_id: Option<String>

Insert before this sibling, or null to append

Move

Move an already-inserted node to a new position within its parent.

Fields

parent_id: String

id: String

before_id: Option<String>

Remove

Remove a node from the tree and deallocate it.

Fields

id: String

Detach

Detach a subtree from its parent without tearing it down.

The renderer must unlink id from its parent’s children list but keep the native element and its descendants alive (same identifier, same props, same children). A subsequent Attach can reinsert the subtree with zero rebuild work. If Remove arrives instead, the subtree is torn down normally.

Used by the Router reconciler to cache off-screen route subtrees, so navigating back to a previously-visited route skips both the engine’s keyed-diff work and the renderer’s element-creation work.

Fields

id: String

Attach

Reattach a previously-Detached subtree to a parent.

The id must reference a still-alive native element that was detached earlier in the session. If before_id is Some, the subtree is inserted before that sibling; None appends.

Fields

parent_id: String

Parent node ID, or "root" for the root container

id: String

before_id: Option<String>

Insert before this sibling, or null to append

Implementations

impl Patch

pub fn create(id: NodeId, element_type: String, props: ResolvedProps) -> Self

Construct a Create patch. props must already be an Arc-wrapped resolved-prop map; callers holding a bare IndexMap wrap it explicitly via Arc::new(...).

pub fn set_prop(id: NodeId, name: String, value: Value) -> Self

pub fn remove_prop(id: NodeId, name: String) -> Self

pub fn set_text(id: NodeId, text: String) -> Self

pub fn insert(parent_id: NodeId, id: NodeId, before_id: Option<NodeId>) -> Self

pub fn insert_root(id: NodeId) -> Self

Insert a root node into the “root” container

pub fn move_node( parent_id: NodeId, id: NodeId, before_id: Option<NodeId>, ) -> Self

pub fn remove(id: NodeId) -> Self

pub fn detach(id: NodeId) -> Self

Emit a Detach patch for the given node.

Instructs the renderer to unlink the subtree rooted at id from its parent without destroying the native element. A subsequent Attach can reinsert it.

pub fn attach(parent_id: NodeId, id: NodeId, before_id: Option<NodeId>) -> Self

Emit an Attach patch to reinsert a previously-detached node as a child of parent_id (with optional before_id position).

pub fn attach_root(id: NodeId, before_id: Option<NodeId>) -> Self

Emit an Attach patch targeting the "root" container. Used when a control-flow container (Router/Conditional) sitting at the IR root caches and re-attaches its matched route’s subtree — the attach has to bypass the container’s own (never-created) NodeId.

Trait Implementations

impl Clone for Patch

fn clone(&self) -> Patch

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Patch

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Patch

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Patch

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

where __S: Serializer,

Serialize this value into the given Serde serializer.