pythonnative 0.20.0__py3-none-any.whl → 0.22.0__py3-none-any.whl

pythonnative/reconciler.py

@@ -1,9 +1,17 @@
-"""Virtual-tree reconciler.
+"""Virtual-tree reconciler with a batched, tag-based commit protocol.
 
 Maintains a tree of [`VNode`][pythonnative.reconciler.VNode] objects
-(each wrapping a native view) and diffs incoming
-[`Element`][pythonnative.Element] trees to apply the minimal set of
-native mutations.
+(each owning an integer **tag** that identifies its native view) and
+diffs incoming [`Element`][pythonnative.Element] trees to compute the
+minimal set of native mutations.
+
+The diff phase is *pure*: it never touches the native layer. Each pass
+appends ops (`pythonnative.mutations`) to a transaction list, and the
+commit applies them through a single
+``backend.apply_mutations(ops)`` call. Event callbacks never cross into
+the native layer at all — they live in the Python-side
+[`EventRegistry`][pythonnative.events.EventRegistry], keyed by tag, so
+re-renders that only produce fresh closures cost nothing natively.
 
 Supports:
 
@@ -15,32 +23,43 @@ Supports:
   context values during tree traversal.
 - **Error boundary elements** (`type == "__ErrorBoundary__"`), which
   catch exceptions in child subtrees and render a fallback.
-- **Key-based child reconciliation** for stable identity across
-  re-renders.
-- **Post-render effect flushing**. After each mount or reconcile pass,
-  all queued effects are executed so they see the committed native tree.
-- **Layout pass**: after every commit, a parallel
-  [`LayoutNode`][pythonnative.layout.LayoutNode] tree is built from
-  the committed VNodes and fed through
-  [`calculate_layout`][pythonnative.layout.calculate_layout]; the
-  resulting per-node frames are applied via the backend's
-  ``set_frame``. The viewport size is supplied by the screen host via
-  [`set_viewport_size`][pythonnative.reconciler.Reconciler.set_viewport_size].
+- **Key-based child reconciliation** with indexed, move-aware inserts
+  (keyed reorders emit one move per child instead of detach-all /
+  re-attach-all).
+- **Post-render effect flushing**. After each commit, all queued
+  effects are executed so they see the committed native tree.
+- **Incremental layout**: a parallel
+  [`LayoutNode`][pythonnative.layout.LayoutNode] tree is cached across
+  passes; clean subtrees keep their cached nodes (enabling the layout
+  engine's measurement memo) and only frames that actually changed are
+  sent to the native side.
 """
 
+import itertools
 import os
-import sys
 from typing import Any, Dict, List, Optional, Tuple
 
 from .element import Element
+from .events import extract_events, get_event_registry
 from .layout import LayoutNode, calculate_layout, extract_layout_style
+from .mutations import CreateOp, DestroyOp, InsertOp, Mutation, SetFrameOp, UpdateOp
 
 # Props the reconciler consumes itself (i.e., never forwards to the
 # native handler). ``ref`` is one such prop: components pass a dict
 # from ``use_ref()`` and the reconciler populates ``ref["current"]``
-# with the underlying native view, mirroring React's ``ref`` semantics.
+# with the underlying native view (and ``ref["_pn_tag"]`` with the
+# view's tag), mirroring React's ``ref`` semantics.
 _RECONCILER_OWNED_PROPS = frozenset({"ref"})
 
+# Tags are globally unique so multiple reconcilers (screens, list rows)
+# can share one registry without collisions.
+_tag_counter = itertools.count(1)
+
+
+def next_tag() -> int:
+    """Allocate a fresh, process-unique view tag."""
+    return next(_tag_counter)
+
 
 def _shallow_equal_props(old: dict, new: dict) -> bool:
     """Return whether two prop dicts are equal under shallow comparison.
@@ -95,20 +114,25 @@ def _flatten_children(children: List[Element]) -> List[Element]:
 
 
 class VNode:
-    """A mounted [`Element`][pythonnative.Element] plus its native view.
+    """A mounted [`Element`][pythonnative.Element] plus its native identity.
 
     The reconciler walks parallel trees of `VNode` and incoming
     `Element` to compute the minimal set of native mutations.
 
     Attributes:
         element: The `Element` last rendered into this slot.
-        native_view: The platform-native view (e.g., an Android `View`
-            or an iOS `UIView`). May be `None` for purely virtual
-            wrappers such as providers and error boundaries.
+        tag: Integer identity of the underlying native view. Native
+            elements own a fresh tag; transparent wrappers (function
+            components, providers, error boundaries) delegate the tag
+            of their rendered subtree root. ``None`` before the subtree
+            renders anything.
+        native_view: The platform-native view object, resolved from the
+            registry after commit. May be `None` for purely virtual
+            wrappers that rendered nothing.
         children: Ordered list of child `VNode` instances.
         parent: The owning `VNode`, or `None` for the tree root. Used
             by local (component-scoped) re-renders to bubble a changed
-            native view up to the nearest native container.
+            subtree root up to the nearest native container.
         hook_state: The component's
             [`HookState`][pythonnative.hooks.HookState] when the node
             wraps a function component, otherwise `None`.
@@ -118,47 +142,67 @@ class VNode:
 
     __slots__ = (
         "element",
+        "tag",
         "native_view",
         "children",
         "parent",
         "hook_state",
         "mounted",
         "_rendered",
+        "_clean_props",
         "_measure_cache",
+        "_last_frame",
+        "_layout_node",
+        "_layout_dirty",
     )
 
-    def __init__(self, element: Element, native_view: Any, children: List["VNode"]) -> None:
+    def __init__(self, element: Element, children: List["VNode"], tag: Optional[int] = None) -> None:
         self.element = element
-        self.native_view = native_view
+        self.tag = tag
+        self.native_view: Any = None
         self.children = children
         self.parent: Optional["VNode"] = None
         self.hook_state: Any = None
         self.mounted: bool = True
         self._rendered: Optional[Element] = None
+        # Native-safe props (callables stripped) from the last commit;
+        # the baseline for prop diffing.
+        self._clean_props: Dict[str, Any] = {}
         # Cache for the leaf intrinsic-size measure callback:
-        # ``(element, max_w, max_h, width, height)``. Lets the layout
-        # pass skip native ``measure_intrinsic`` calls for leaves whose
-        # element *object* (compared by identity) and constraints are
-        # unchanged since the last measure. Because untouched components
-        # keep their exact ``Element`` instances across a local
-        # re-render, this turns "re-measure everything every layout pass"
-        # into "re-measure only what actually re-rendered".
-        self._measure_cache: Optional[Tuple[Any, float, float, float, float]] = None
+        # ``(max_w, max_h, width, height)``. Invalidated whenever the
+        # node's props change, so unchanged leaves skip native
+        # ``measure_intrinsic`` calls entirely.
+        self._measure_cache: Optional[Tuple[float, float, float, float]] = None
+        # Last frame sent to the native side — frames that don't change
+        # are skipped (frame diffing).
+        self._last_frame: Optional[Tuple[float, float, float, float]] = None
+        # Cached LayoutNode reused across passes while the subtree is
+        # clean (see Reconciler._build_layout_tree_cached).
+        self._layout_node: Optional[LayoutNode] = None
+        # True when this node's layout-relevant props or child list
+        # changed since the last layout pass.
+        self._layout_dirty: bool = True
 
 
 class Reconciler:
     """Create, diff, and patch native view trees from `Element` descriptors.
 
-    After each [`mount`][pythonnative.reconciler.Reconciler.mount] or
-    [`reconcile`][pythonnative.reconciler.Reconciler.reconcile] call the
-    reconciler walks the committed tree and flushes all pending effects
-    so effect callbacks run *after* native mutations are applied.
+    After each [`mount`][pythonnative.reconciler.Reconciler.mount],
+    [`reconcile`][pythonnative.reconciler.Reconciler.reconcile], or
+    [`flush_dirty`][pythonnative.reconciler.Reconciler.flush_dirty]
+    pass the reconciler:
+
+    1. applies the accumulated mutation ops in one batch,
+    2. resolves freshly created native views and populates refs,
+    3. flushes pending effects (so they see the committed tree), and
+    4. runs the layout pass, emitting only changed frames.
 
     Args:
-        backend: An object implementing the native-view protocol
-            (`create_view`, `update_view`, `add_child`, `remove_child`,
-            `insert_child`). PythonNative ships an Android backend and
-            an iOS backend; tests can pass a mock.
+        backend: An object implementing the registry protocol
+            (``apply_mutations``, ``resolve_view``,
+            ``measure_intrinsic``, ``command``). PythonNative ships
+            Android, iOS, and desktop registries; tests can pass a
+            registry stocked with mock handlers.
     """
 
     def __init__(self, backend: Any) -> None:
@@ -167,6 +211,10 @@ class Reconciler:
         self._screen_re_render: Optional[Any] = None
         self._viewport_size: Tuple[float, float] = (0.0, 0.0)
         self._layout_pass = 0
+        self._events = get_event_registry()
+        # Transaction state for the in-flight pass.
+        self._ops: List[Mutation] = []
+        self._created: List[VNode] = []
         # Function-component VNodes whose own state changed since the
         # last flush, keyed by ``id`` to dedupe while keeping a strong
         # reference. Drained by
@@ -187,15 +235,10 @@ class Reconciler:
             The platform-native view that represents the root of the
             mounted tree.
         """
-        self._log_viewport(
-            f"mount: start type={self._type_label(element.type)!r} props={self._props_debug(element.props)}"
-        )
+        self._log(f"mount: start type={self._type_label(element.type)!r}")
         self._dirty_nodes.clear()
         self._tree = self._create_tree(element)
-        self._log_viewport(f"mount: tree created root={self._node_debug(self._tree)}")
-        self._flush_effects()
-        self._run_layout()
-        self._log_viewport(f"mount: done root_view={self._obj_debug(self._tree.native_view)}")
+        self._commit()
         return self._tree.native_view
 
     def reconcile(self, new_element: Element) -> Any:
@@ -207,32 +250,39 @@ class Reconciler:
         Returns:
             The (possibly replaced) root native view.
         """
-        self._log_viewport(
-            "reconcile: entering "
-            f"(have_tree={self._tree is not None}) new_type={self._type_label(new_element.type)!r} "
-            f"new_props={self._props_debug(new_element.props)}"
-        )
         # A full reconcile rebuilds the whole tree from the root, so any
         # pending per-component dirty marks are now obsolete.
         self._dirty_nodes.clear()
         if self._tree is None:
             self._tree = self._create_tree(new_element)
-            self._log_viewport(f"reconcile: created initial root={self._node_debug(self._tree)}")
-            self._flush_effects()
-            self._run_layout()
-            return self._tree.native_view
-
-        self._tree = self._reconcile_node(self._tree, new_element)
-        self._log_viewport(f"reconcile: tree reconciled root={self._node_debug(self._tree)}")
-        self._flush_effects()
-        self._run_layout()
-        self._log_viewport("reconcile: done")
+        else:
+            self._tree = self._reconcile_node(self._tree, new_element)
+        self._commit()
         return self._tree.native_view
 
     def root_view(self) -> Any:
         """Return the current root native view, or ``None`` before mount."""
         return self._tree.native_view if self._tree is not None else None
 
+    def root_tag(self) -> Optional[int]:
+        """Return the root native view's tag, or ``None`` before mount."""
+        return self._tree.tag if self._tree is not None else None
+
+    def unmount(self) -> None:
+        """Destroy the entire mounted tree and release native views."""
+        if self._tree is None:
+            return
+        self._destroy_tree(self._tree)
+        self._tree = None
+        self._dirty_nodes.clear()
+        self._flush_ops()
+
+    def dispatch_command(self, tag: Optional[int], name: str, args: Optional[Dict[str, Any]] = None) -> Any:
+        """Run an imperative command against the view registered under ``tag``."""
+        if tag is None:
+            return None
+        return self.backend.command(tag, name, args or {})
+
     def mark_dirty(self, vnode: "VNode") -> None:
         """Queue ``vnode`` (a function component) for a local re-render.
 
@@ -258,7 +308,8 @@ class Reconciler:
         its subtree. Nodes are processed shallowest-first so that when a
         dirty ancestor's re-render already covers a dirty descendant, the
         descendant is skipped (its ``_dirty`` flag is cleared by the
-        ancestor pass).
+        ancestor pass). The whole batch commits as one native
+        transaction.
 
         Returns:
             The (possibly replaced) root native view, so the host can
@@ -289,9 +340,94 @@ class Reconciler:
                 # the exception propagates, matching a full render.
                 self._handle_local_render_error(vnode, exc)
 
+        self._commit()
+        return self._tree.native_view
+
+    def set_viewport_size(self, width: float, height: float) -> None:
+        """Update the viewport size and re-run layout if it changed.
+
+        Called by the screen host whenever the platform reports a new
+        container size (Android: ``onLayoutChange``; iOS:
+        ``viewDidLayoutSubviews``). The first call after mount
+        triggers the initial layout pass; subsequent identical
+        sizes are no-ops.
+
+        Args:
+            width: Viewport width in points.
+            height: Viewport height in points.
+        """
+        if width <= 0 or height <= 0:
+            return
+        if self._viewport_size == (width, height):
+            return
+        self._viewport_size = (width, height)
+        if self._tree is not None:
+            self._run_layout()
+            self._flush_ops()
+
+    # ------------------------------------------------------------------
+    # Commit driver
+    # ------------------------------------------------------------------
+
+    def _commit(self) -> None:
+        """Apply the accumulated transaction and run the post-commit phases."""
+        self._flush_ops()
         self._flush_effects()
         self._run_layout()
-        return self._tree.native_view
+        self._flush_ops()
+
+    def _flush_ops(self) -> None:
+        """Send pending ops to the backend and resolve created views."""
+        ops = self._ops
+        created = self._created
+        if ops:
+            self._ops = []
+            self._created = []
+            self.backend.apply_mutations(ops)
+        elif created:
+            self._created = []
+        for vnode in created:
+            if not vnode.mounted or vnode.tag is None:
+                continue
+            vnode.native_view = self.backend.resolve_view(vnode.tag)
+            self._attach_ref(vnode.element, vnode.native_view, vnode.tag)
+
+    # ------------------------------------------------------------------
+    # Effect flushing
+    # ------------------------------------------------------------------
+
+    def _flush_effects(self) -> None:
+        """Walk the committed tree and flush pending effects (depth-first).
+
+        This post-commit walk doubles as the single source of truth for
+        ``VNode.parent`` links and for *delegated* identity: transparent
+        wrappers (components, providers, boundaries) re-derive their
+        ``tag`` / ``native_view`` from their subtree root here, so the
+        rest of the reconciler never has to chase delegation chains by
+        hand. The cost is folded into a walk the reconciler already runs
+        after every commit.
+        """
+        if self._tree is not None:
+            self._tree.parent = None
+            self._flush_tree_effects(self._tree)
+
+    def _flush_tree_effects(self, node: VNode) -> None:
+        for child in node.children:
+            child.parent = node
+            self._flush_tree_effects(child)
+        if not self._is_native_node(node):
+            if node.children:
+                node.tag = node.children[0].tag
+                node.native_view = node.children[0].native_view
+            else:
+                node.tag = None
+                node.native_view = None
+        if node.hook_state is not None:
+            node.hook_state.flush_pending_effects()
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
 
     @staticmethod
     def _node_depth(vnode: "VNode") -> int:
@@ -338,7 +474,7 @@ class Reconciler:
                 _set_hook_state(None)
                 hook_state._dirty = False
 
-            old_native = vnode.native_view
+            old_tag = vnode.tag
             if vnode.children:
                 child = self._reconcile_node(vnode.children[0], rendered)
             else:
@@ -349,11 +485,12 @@ class Reconciler:
 
         child.parent = vnode
         vnode.children = [child]
+        vnode.tag = child.tag
         vnode.native_view = child.native_view
         vnode._rendered = rendered
 
-        if child.native_view is not old_native:
-            self._bubble_native_view_change(vnode, old_native, child.native_view)
+        if child.tag != old_tag:
+            self._bubble_root_change(vnode, child)
 
     def _handle_local_render_error(self, vnode: "VNode", exc: Exception) -> None:
         """Route a local re-render failure to the nearest ``ErrorBoundary`` ancestor.
@@ -368,7 +505,7 @@ class Reconciler:
         node = vnode.parent
         while node is not None:
             if isinstance(node.element.type, str) and node.element.type == "__ErrorBoundary__":
-                old_native = node.native_view
+                old_tag = node.tag
                 # Like a local component update, this re-reconcile starts
                 # mid-tree, so restore the boundary's own ancestor
                 # provider context first.
@@ -380,8 +517,8 @@ class Reconciler:
                 finally:
                     for context, _value in reversed(providers):
                         context._stack.pop()
-                if node.native_view is not old_native:
-                    self._bubble_native_view_change(node, old_native, node.native_view)
+                if node.tag != old_tag and node.children:
+                    self._bubble_root_change(node, node.children[0])
                 return
             node = node.parent
         raise exc
@@ -404,74 +541,46 @@ class Reconciler:
         chain.reverse()
         return chain
 
-    def _bubble_native_view_change(self, vnode: "VNode", old_native: Any, new_native: Any) -> None:
-        """Propagate a changed subtree-root native view up to its native parent.
+    def _bubble_root_change(self, vnode: "VNode", new_subtree_root: "VNode") -> None:
+        """Propagate a swapped subtree-root view up to its native parent.
 
         A local re-render starts below the real native container, so when
-        the dirty component's root native view is swapped (e.g. its output
-        changed type), the change must be reflected in (a) every
-        transparent ancestor that delegated its ``native_view`` to this
-        subtree and (b) the nearest native-container ancestor's child list.
+        the dirty component's root native view is replaced (e.g. its
+        output changed type), the change must be reflected in (a) every
+        transparent ancestor that delegated its identity to this subtree
+        and (b) the nearest native-container ancestor's child list. The
+        old view's detach is implied by its `DestroyOp` (handlers detach
+        on destroy); only the indexed insert of the new root is emitted.
         """
         child = vnode
         node = vnode.parent
         while node is not None:
-            if self._is_native_container(node):
+            if self._is_native_node(node):
                 try:
-                    idx: Optional[int] = node.children.index(child)
+                    idx = node.children.index(child)
                 except ValueError:
-                    idx = None
-                if old_native is not None:
-                    self.backend.remove_child(node.native_view, old_native, node.element.type)
-                if new_native is not None:
-                    if idx is None:
-                        self.backend.add_child(node.native_view, new_native, node.element.type)
-                    else:
-                        self.backend.insert_child(node.native_view, new_native, node.element.type, idx)
+                    idx = len(node.children) - 1
+                if node.tag is not None and new_subtree_root.tag is not None:
+                    self._ops.append(InsertOp(node.tag, new_subtree_root.tag, idx))
+                self._mark_layout_dirty(node)
                 return
-            # Transparent ancestor (component / provider / error boundary /
-            # fragment) delegates its native view to this subtree.
-            if node.native_view is old_native:
-                node.native_view = new_native
+            # Transparent ancestor delegates its identity to this subtree.
+            node.tag = new_subtree_root.tag
+            node.native_view = new_subtree_root.native_view
             child = node
             node = node.parent
         # Reached the root with no native container above: the root's
-        # ``native_view`` was already updated in the loop. The host
-        # detects the change by comparing ``root_view()`` after the flush.
+        # identity was already updated in the loop. The host detects the
+        # change by comparing ``root_view()`` after the flush.
 
     @staticmethod
-    def _is_native_container(node: "VNode") -> bool:
+    def _is_native_node(node: "VNode") -> bool:
         t = node.element.type
         return isinstance(t, str) and t not in ("__Provider__", "__ErrorBoundary__", "__Fragment__")
 
-    def set_viewport_size(self, width: float, height: float) -> None:
-        """Update the viewport size and re-run layout if it changed.
-
-        Called by the screen host whenever the platform reports a new
-        container size (Android: ``onLayoutChange``; iOS:
-        ``viewDidLayoutSubviews``). The first call after mount
-        triggers the initial layout pass; subsequent identical
-        sizes are no-ops.
-
-        Args:
-            width: Viewport width in points.
-            height: Viewport height in points.
-        """
-        if width <= 0 or height <= 0:
-            self._log_viewport(f"set_viewport_size: ignored non-positive ({width},{height})")
-            return
-        if self._viewport_size == (width, height):
-            self._log_viewport(f"set_viewport_size: unchanged at ({width},{height})")
-            return
-        prev = self._viewport_size
-        self._viewport_size = (width, height)
-        self._log_viewport(f"set_viewport_size: {prev} -> ({width},{height}); running layout")
-        if self._tree is not None:
-            self._run_layout()
-
     @staticmethod
-    def _log_viewport(msg: str) -> None:
-        """Emit optional layout diagnostics for local debugging."""
+    def _log(msg: str) -> None:
+        """Emit optional diagnostics for local debugging."""
         if os.environ.get("PYTHONNATIVE_DEBUG", "").lower() not in {"1", "true", "yes", "on"}:
             return
         try:
@@ -485,82 +594,8 @@ class Reconciler:
             return type_obj
         return getattr(type_obj, "__name__", repr(type_obj))
 
-    @staticmethod
-    def _obj_debug(obj: Any) -> str:
-        if obj is None:
-            return "<None>"
-        ptr = getattr(obj, "ptr", None)
-        addr: Optional[int] = None
-        if isinstance(ptr, (bytes, bytearray)):
-            try:
-                addr = int.from_bytes(ptr, byteorder=sys.byteorder, signed=False)
-            except Exception:
-                addr = None
-        elif isinstance(ptr, int):
-            addr = ptr
-        elif ptr is not None:
-            value = getattr(ptr, "value", None)
-            if isinstance(value, int):
-                addr = value
-            else:
-                try:
-                    addr = int(ptr)
-                except Exception:
-                    addr = None
-        addr_part = f" ptr=0x{addr:x}" if addr is not None else ""
-        return f"{type(obj).__name__}(py_id=0x{id(obj):x}{addr_part})"
-
-    @classmethod
-    def _props_debug(cls, props: dict) -> str:
-        interesting = []
-        for key in ("title", "text", "active_tab", "scroll_axis", "width", "height", "flex", "key"):
-            if key in props:
-                interesting.append(f"{key}={props[key]!r}")
-        if "items" in props and isinstance(props["items"], list):
-            names = [item.get("name", item.get("title", "")) for item in props["items"][:4]]
-            interesting.append(f"items_len={len(props['items'])} items={names!r}")
-        callback_keys = sorted(key for key, value in props.items() if callable(value))
-        if callback_keys:
-            interesting.append(f"callbacks={callback_keys!r}")
-        return "{" + ", ".join(interesting) + "}"
-
-    @classmethod
-    def _node_debug(cls, vnode: VNode) -> str:
-        element = vnode.element
-        return (
-            f"type={cls._type_label(element.type)!r} key={element.key!r} "
-            f"props={cls._props_debug(element.props)} view={cls._obj_debug(vnode.native_view)}"
-        )
-
-    # ------------------------------------------------------------------
-    # Effect flushing
-    # ------------------------------------------------------------------
-
-    def _flush_effects(self) -> None:
-        """Walk the committed tree and flush pending effects (depth-first).
-
-        This post-commit walk doubles as the single source of truth for
-        ``VNode.parent``: every live node's parent pointer is re-linked
-        here so that local re-renders
-        ([`flush_dirty`][pythonnative.reconciler.Reconciler.flush_dirty])
-        can compute node depth and bubble native-view changes upward
-        without each reconcile path having to maintain parent links by
-        hand. The cost is folded into a walk the reconciler already runs
-        after every commit.
-        """
-        if self._tree is not None:
-            self._tree.parent = None
-            self._flush_tree_effects(self._tree)
-
-    def _flush_tree_effects(self, node: VNode) -> None:
-        for child in node.children:
-            child.parent = node
-            self._flush_tree_effects(child)
-        if node.hook_state is not None:
-            node.hook_state.flush_pending_effects()
-
     # ------------------------------------------------------------------
-    # Internal helpers
+    # Tree creation
     # ------------------------------------------------------------------
 
     def _create_tree(self, element: Element) -> VNode:
@@ -573,9 +608,10 @@ class Reconciler:
                 child_node = self._create_tree(provider_children[0]) if provider_children else None
             finally:
                 context._stack.pop()
-            native_view = child_node.native_view if child_node else None
             children = [child_node] if child_node else []
-            return VNode(element, native_view, children)
+            vnode = VNode(element, children)
+            vnode.tag = child_node.tag if child_node else None
+            return vnode
 
         # Error boundary: catch exceptions in the child subtree
         if element.type == "__ErrorBoundary__":
@@ -587,9 +623,11 @@ class Reconciler:
         if element.type == "__Fragment__":
             kids = _flatten_children(element.children)
             if not kids:
-                return VNode(element, None, [])
+                return VNode(element, [])
             child_node = self._create_tree(kids[0])
-            return VNode(element, child_node.native_view, [child_node])
+            vnode = VNode(element, [child_node])
+            vnode.tag = child_node.tag
+            return vnode
 
         # Function component: call with hook context
         if callable(element.type):
@@ -605,7 +643,8 @@ class Reconciler:
                 hook_state._dirty = False
 
             child_node = self._create_tree(rendered)
-            vnode = VNode(element, child_node.native_view, [child_node])
+            vnode = VNode(element, [child_node])
+            vnode.tag = child_node.tag
             vnode.hook_state = hook_state
             vnode._rendered = rendered
             hook_state._vnode = vnode
@@ -613,46 +652,21 @@ class Reconciler:
             return vnode
 
         # Native element
-        self._log_viewport(
-            f"_create_tree: native start type={element.type!r} props={self._props_debug(element.props)} "
-            f"children={len(element.children)}"
-        )
-        handler_props = self._strip_reconciler_props(element.props)
-        try:
-            native_view = self.backend.create_view(element.type, handler_props)
-        except Exception as e:
-            self._log_viewport(f"_create_tree: BACKEND.create_view({element.type!r}) RAISED {type(e).__name__}: {e!r}")
-            raise
-        self._log_viewport(f"_create_tree: native created type={element.type!r} view={self._obj_debug(native_view)}")
-        self._attach_ref(element, native_view)
-        children: List[VNode] = []
+        tag = next_tag()
+        clean_props, events = self._split_props(element.props)
+        vnode = VNode(element, [], tag=tag)
+        vnode._clean_props = clean_props
+        if events:
+            self._events.set_events(tag, events)
+        self._ops.append(CreateOp(tag, element.type, clean_props))
+        self._created.append(vnode)
+
         flat_children = _flatten_children(element.children)
         for i, child_el in enumerate(flat_children):
-            child_type = self._type_label(child_el.type)
-            self._log_viewport(f"_create_tree: creating child[{i}] type={child_type!r} of {element.type!r}")
-            try:
-                child_node = self._create_tree(child_el)
-            except Exception as e:
-                self._log_viewport(
-                    f"_create_tree: child[{i}] (type={child_type!r}) of {element.type!r} RAISED "
-                    f"{type(e).__name__}: {e!r}"
-                )
-                raise
-            self._log_viewport(
-                f"_create_tree: add child[{i}] parent={element.type!r} child={self._node_debug(child_node)}"
-            )
-            try:
-                self.backend.add_child(native_view, child_node.native_view, element.type)
-            except Exception as e:
-                self._log_viewport(
-                    f"_create_tree: backend.add_child(parent={element.type!r}, "
-                    f"child={child_type!r}) RAISED {type(e).__name__}: {e!r}"
-                )
-                raise
-            self._log_viewport(f"_create_tree: add child[{i}] done parent={element.type!r}")
-            children.append(child_node)
-        vnode = VNode(element, native_view, children)
-        self._log_viewport(f"_create_tree: native done {self._node_debug(vnode)} children={len(children)}")
+            child_node = self._create_tree(child_el)
+            if child_node.tag is not None:
+                self._ops.append(InsertOp(tag, child_node.tag, i))
+            vnode.children.append(child_node)
         return vnode
 
     def _create_error_boundary(self, element: Element) -> VNode:
@@ -666,20 +680,19 @@ class Reconciler:
                 child_node = self._create_tree(fallback_el)
             else:
                 raise
-        native_view = child_node.native_view if child_node else None
         children = [child_node] if child_node else []
-        return VNode(element, native_view, children)
+        vnode = VNode(element, children)
+        vnode.tag = child_node.tag if child_node else None
+        return vnode
+
+    # ------------------------------------------------------------------
+    # Reconciliation
+    # ------------------------------------------------------------------
 
     def _reconcile_node(self, old: VNode, new_el: Element) -> VNode:
         if not self._same_type(old.element, new_el):
-            self._log_viewport(
-                "_reconcile_node: replace "
-                f"old={self._node_debug(old)} new_type={self._type_label(new_el.type)!r} "
-                f"new_props={self._props_debug(new_el.props)}"
-            )
             new_node = self._create_tree(new_el)
             self._destroy_tree(old)
-            self._log_viewport(f"_reconcile_node: replace done new={self._node_debug(new_node)}")
             return new_node
 
         # Provider
@@ -691,10 +704,12 @@ class Reconciler:
                 if old.children and provider_kids:
                     child = self._reconcile_node(old.children[0], provider_kids[0])
                     old.children = [child]
+                    old.tag = child.tag
                     old.native_view = child.native_view
                 elif provider_kids:
                     child = self._create_tree(provider_kids[0])
                     old.children = [child]
+                    old.tag = child.tag
                     old.native_view = child.native_view
             finally:
                 context._stack.pop()
@@ -715,7 +730,6 @@ class Reconciler:
             # previously-rendered subtree without invoking the body.
             if self._can_skip_memoized(old, new_el):
                 old.element = new_el
-                self._log_viewport(f"_reconcile_node: memo skip type={self._type_label(new_el.type)!r}")
                 return old
 
             hook_state = old.hook_state
@@ -737,6 +751,7 @@ class Reconciler:
             else:
                 child = self._create_tree(rendered)
             old.children = [child]
+            old.tag = child.tag
             old.native_view = child.native_view
             old.element = new_el
             old.hook_state = hook_state
@@ -746,17 +761,17 @@ class Reconciler:
             return old
 
         # Native element
-        changed = self._diff_props(old.element.props, new_el.props)
+        new_clean, events = self._split_props(new_el.props)
+        if old.tag is not None:
+            self._events.set_events(old.tag, events)
+        changed = self._diff_props(old._clean_props, new_clean)
         if changed:
-            self._log_viewport(
-                "_reconcile_node: native update "
-                f"type={old.element.type!r} view={self._obj_debug(old.native_view)} "
-                f"changed={self._props_debug(changed)}"
-            )
-            self.backend.update_view(old.native_view, old.element.type, changed)
-            self._log_viewport(f"_reconcile_node: native update done type={old.element.type!r}")
-        else:
-            self._log_viewport(f"_reconcile_node: native unchanged type={old.element.type!r}")
+            if old.tag is not None:
+                self._ops.append(UpdateOp(old.tag, changed))
+            old._measure_cache = None
+            if self._affects_layout(old.element.type, changed):
+                self._mark_layout_dirty(old)
+        old._clean_props = new_clean
 
         # Re-attach the ref if the ref dict identity changed (so we
         # never leave a stale ref pointing at a destroyed view, and so
@@ -769,14 +784,10 @@ class Reconciler:
                     old_ref["current"] = None
                 except Exception:
                     pass
-            self._attach_ref(new_el, old.native_view)
+            self._attach_ref(new_el, old.native_view, old.tag)
 
-        self._log_viewport(
-            f"_reconcile_node: reconcile children parent={old.element.type!r} new_children={len(new_el.children)}"
-        )
         self._reconcile_children(old, new_el.children)
         old.element = new_el
-        self._log_viewport(f"_reconcile_node: native done {self._node_debug(old)} children={len(old.children)}")
         return old
 
     def _reconcile_error_boundary(self, old: VNode, new_el: Element) -> VNode:
@@ -786,10 +797,12 @@ class Reconciler:
             if old.children and eb_kids:
                 child = self._reconcile_node(old.children[0], eb_kids[0])
                 old.children = [child]
+                old.tag = child.tag
                 old.native_view = child.native_view
             elif eb_kids:
                 child = self._create_tree(eb_kids[0])
                 old.children = [child]
+                old.tag = child.tag
                 old.native_view = child.native_view
         except Exception as exc:
             for c in old.children:
@@ -798,6 +811,7 @@ class Reconciler:
                 fallback_el = fallback_fn(exc) if callable(fallback_fn) else fallback_fn
                 child = self._create_tree(fallback_el)
                 old.children = [child]
+                old.tag = child.tag
                 old.native_view = child.native_view
             else:
                 raise
@@ -832,12 +846,8 @@ class Reconciler:
     def _reconcile_children(self, parent: VNode, new_children: List[Element]) -> None:
         new_children = _flatten_children(new_children)
         old_children = parent.children
-        parent_type = parent.element.type
-        is_native = isinstance(parent_type, str) and parent_type not in (
-            "__Provider__",
-            "__ErrorBoundary__",
-            "__Fragment__",
-        )
+        is_native = self._is_native_node(parent)
+        parent_tag = parent.tag if is_native else None
 
         old_by_key: dict = {}
         old_unkeyed: list = []
@@ -850,6 +860,10 @@ class Reconciler:
         new_child_nodes: List[VNode] = []
         used_keyed: set = set()
         unkeyed_iter = iter(old_unkeyed)
+        # ``(index, vnode)`` pairs that need an indexed insert once the
+        # stale children have been removed (see op-ordering note below).
+        pending_inserts: List[Tuple[int, VNode]] = []
+        structure_changed = False
 
         for i, new_el in enumerate(new_children):
             matched: Optional[VNode] = None
@@ -861,75 +875,60 @@ class Reconciler:
                 matched = next(unkeyed_iter, None)
 
             if matched is None:
-                self._log_viewport(
-                    f"_reconcile_children: create child[{i}] parent={self._type_label(parent_type)!r} "
-                    f"type={self._type_label(new_el.type)!r}"
-                )
                 node = self._create_tree(new_el)
-                if is_native:
-                    self._log_viewport(
-                        f"_reconcile_children: add new child[{i}] parent={self._obj_debug(parent.native_view)} "
-                        f"child={self._obj_debug(node.native_view)}"
-                    )
-                    self.backend.add_child(parent.native_view, node.native_view, parent_type)
+                pending_inserts.append((i, node))
+                structure_changed = True
                 new_child_nodes.append(node)
             elif not self._same_type(matched.element, new_el):
-                self._log_viewport(
-                    f"_reconcile_children: replace child[{i}] old={self._node_debug(matched)} "
-                    f"new_type={self._type_label(new_el.type)!r}"
-                )
-                if is_native:
-                    self.backend.remove_child(parent.native_view, matched.native_view, parent_type)
-                self._destroy_tree(matched)
                 node = self._create_tree(new_el)
-                if is_native:
-                    self.backend.insert_child(parent.native_view, node.native_view, parent_type, i)
+                self._destroy_tree(matched)
+                pending_inserts.append((i, node))
+                structure_changed = True
                 new_child_nodes.append(node)
             else:
-                old_native = matched.native_view
-                self._log_viewport(f"_reconcile_children: update child[{i}] {self._node_debug(matched)}")
+                old_tag = matched.tag
                 updated = self._reconcile_node(matched, new_el)
-                if is_native and updated.native_view is not old_native:
-                    self._log_viewport(
-                        f"_reconcile_children: child[{i}] native view changed "
-                        f"old={self._obj_debug(old_native)} new={self._obj_debug(updated.native_view)}"
-                    )
-                    self.backend.remove_child(parent.native_view, old_native, parent_type)
-                    self.backend.insert_child(parent.native_view, updated.native_view, parent_type, i)
+                if updated.tag != old_tag:
+                    # The child's subtree root was replaced in place
+                    # (transparent wrapper whose output changed type).
+                    pending_inserts.append((i, updated))
+                    structure_changed = True
                 new_child_nodes.append(updated)
 
-        # Destroy unused old nodes
+        # Destroy unused old nodes first: handlers detach on destroy, so
+        # the native child list contains only kept children (in their old
+        # relative order) by the time the indexed inserts apply.
         for key, node in old_by_key.items():
             if key not in used_keyed:
-                self._log_viewport(f"_reconcile_children: destroy unused keyed key={key!r} {self._node_debug(node)}")
-                if is_native:
-                    self.backend.remove_child(parent.native_view, node.native_view, parent_type)
                 self._destroy_tree(node)
+                structure_changed = True
         for node in unkeyed_iter:
-            self._log_viewport(f"_reconcile_children: destroy unused unkeyed {self._node_debug(node)}")
-            if is_native:
-                self.backend.remove_child(parent.native_view, node.native_view, parent_type)
             self._destroy_tree(node)
-
-        # Reorder native children when keyed children changed positions.
-        # Without this, native sibling order drifts from the logical tree
-        # when keyed children swap positions across reconcile passes.
-        if is_native and used_keyed:
-            old_key_order = [c.element.key for c in old_children if c.element.key in used_keyed]
-            new_key_order = [n.element.key for n in new_child_nodes if n.element.key in used_keyed]
-            if old_key_order != new_key_order:
-                self._log_viewport(
-                    f"_reconcile_children: reorder keyed children old={old_key_order!r} new={new_key_order!r}"
-                )
-                for node in new_child_nodes:
-                    self.backend.remove_child(parent.native_view, node.native_view, parent_type)
-                for node in new_child_nodes:
-                    self.backend.add_child(parent.native_view, node.native_view, parent_type)
+            structure_changed = True
+
+        if is_native and parent_tag is not None:
+            for index, node in pending_inserts:
+                if node.tag is not None:
+                    self._ops.append(InsertOp(parent_tag, node.tag, index))
+
+            # Keyed reorder: when the kept children changed relative
+            # order, emit one move-aware insert per child in final
+            # order. Applying "ensure child at index i" sequentially for
+            # i = 0..n-1 converges to the target order, and handlers
+            # no-op when the child is already in place.
+            if used_keyed:
+                old_key_order = [c.element.key for c in old_children if c.element.key in used_keyed]
+                new_key_order = [n.element.key for n in new_child_nodes if n.element.key in used_keyed]
+                if old_key_order != new_key_order:
+                    structure_changed = True
+                    for i, node in enumerate(new_child_nodes):
+                        if node.tag is not None:
+                            self._ops.append(InsertOp(parent_tag, node.tag, i))
+
+        if structure_changed:
+            self._mark_layout_dirty(parent)
 
         parent.children = new_child_nodes
-        self._log_viewport(
-            f"_reconcile_children: done parent={self._type_label(parent_type)!r} children={len(parent.children)}"
-        )
 
     def _destroy_tree(self, node: VNode) -> None:
         node.mounted = False
@@ -949,33 +948,69 @@ class Reconciler:
             self._detach_ref(node.element)
         for child in node.children:
             self._destroy_tree(child)
+        if self._is_native_node(node) and node.tag is not None:
+            self._events.clear(node.tag)
+            self._ops.append(DestroyOp(node.tag))
         node.children = []
         node.parent = None
+        node._layout_node = None
 
-    @staticmethod
-    def _strip_reconciler_props(props: dict) -> dict:
-        """Return ``props`` with reconciler-owned keys removed.
+    # ------------------------------------------------------------------
+    # Prop handling
+    # ------------------------------------------------------------------
+
+    def _split_props(self, props: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Strip reconciler-owned keys, then split events from native props.
 
         Reconciler-owned keys (``ref``, internal ``__*__`` keys) are
         consumed by the reconciler itself and must never reach the
-        native handler — handlers don't know what to do with them and
-        would incorrectly forward them to the underlying view.
+        native handler. Event callables are routed to the
+        [`EventRegistry`][pythonnative.events.EventRegistry] and the
+        remaining payload is safe to diff with plain ``==``.
         """
         if not props:
-            return props
+            return {}, {}
         stripped = {}
         for key, value in props.items():
             if key in _RECONCILER_OWNED_PROPS or key.startswith("__"):
                 continue
             stripped[key] = value
-        return stripped
+        return extract_events(stripped)
+
+    @staticmethod
+    def _diff_props(old: dict, new: dict) -> dict:
+        """Return only the props that changed between two clean prop dicts.
+
+        Event callables never appear here (they live in the event
+        registry), so listener identity churn produces no native
+        traffic — only the ``_pn_events`` name set is compared.
+        """
+        changed = {}
+        for key, new_val in new.items():
+            old_val = old.get(key)
+            if key not in old:
+                changed[key] = new_val
+                continue
+            try:
+                if callable(new_val) or callable(old_val):
+                    if old_val is not new_val:
+                        changed[key] = new_val
+                elif old_val != new_val:
+                    changed[key] = new_val
+            except Exception:
+                changed[key] = new_val
+        for key in old:
+            if key not in new:
+                changed[key] = None
+        return changed
 
     @staticmethod
-    def _attach_ref(element: Element, native_view: Any) -> None:
-        """Set ``ref["current"]`` if the element carries a ``ref`` prop."""
+    def _attach_ref(element: Element, native_view: Any, tag: Optional[int]) -> None:
+        """Populate ``ref["current"]`` (and the internal tag) if a ``ref`` prop exists."""
         ref = element.props.get("ref") if element.props else None
         if isinstance(ref, dict):
             ref["current"] = native_view
+            ref["_pn_tag"] = tag
 
     @staticmethod
     def _detach_ref(element: Element) -> None:
@@ -984,6 +1019,7 @@ class Reconciler:
         if isinstance(ref, dict):
             try:
                 ref["current"] = None
+                ref["_pn_tag"] = None
             except Exception:
                 pass
 
@@ -993,93 +1029,93 @@ class Reconciler:
             return old_el.type == new_el.type
         return old_el.type is new_el.type
 
-    @staticmethod
-    def _diff_props(old: dict, new: dict) -> dict:
-        """Return only the props that changed.
-
-        Callables always count as changed (we cannot compare two
-        closures cheaply, and event handlers are usually fresh on every
-        render). Internal `__*__` props are skipped because they are
-        consumed by the reconciler itself, not the native handler.
-        Reconciler-owned props (``ref``) are also skipped because they
-        are managed via ``_attach_ref`` / ``_detach_ref`` and never
-        forwarded to the native handler.
-        """
-        changed = {}
-        for key, new_val in new.items():
-            if key.startswith("__") or key in _RECONCILER_OWNED_PROPS:
-                continue
-            old_val = old.get(key)
-            if callable(new_val) or old_val != new_val:
-                changed[key] = new_val
-        for key in old:
-            if key.startswith("__") or key in _RECONCILER_OWNED_PROPS:
-                continue
-            if key not in new:
-                changed[key] = None
-        return changed
-
     # ------------------------------------------------------------------
     # Layout pass
     # ------------------------------------------------------------------
 
+    _INTRINSIC_TYPES = frozenset(
+        {
+            "Text",
+            "Button",
+            "Image",
+            "TextInput",
+            "Switch",
+            "Slider",
+            "ProgressBar",
+            "ActivityIndicator",
+            "TabBar",
+            "Picker",
+            "Checkbox",
+            "SegmentedControl",
+            "DatePicker",
+        }
+    )
+
+    @classmethod
+    def _affects_layout(cls, type_name: str, changed: Dict[str, Any]) -> bool:
+        """Whether ``changed`` props can alter the node's layout.
+
+        Content-sized leaves re-measure on *any* prop change (text,
+        font, image source — almost everything affects their intrinsic
+        size). Containers only care about the layout style keys.
+        """
+        if type_name in cls._INTRINSIC_TYPES:
+            return True
+        from .layout import LAYOUT_STYLE_KEYS
+
+        return any(key in LAYOUT_STYLE_KEYS for key in changed)
+
+    @staticmethod
+    def _mark_layout_dirty(vnode: VNode) -> None:
+        vnode._layout_dirty = True
+        vnode._layout_node = None
+
     def _run_layout(self) -> None:
-        """Build a layout tree from the committed VNodes and apply frames.
+        """Build/refresh the layout tree, compute frames, and emit changed ones.
 
-        Wraps the user's root VNode in a synthetic outer
-        `LayoutNode` with the viewport size so the user's root
-        always fills the screen by default (matching React Native).
-        Skipped silently until the screen host has supplied a
-        viewport size via
+        Wraps the user's root VNode in a synthetic outer `LayoutNode`
+        with the viewport size so the user's root always fills the
+        screen by default (matching React Native). Skipped silently
+        until the screen host has supplied a viewport size via
         [`set_viewport_size`][pythonnative.reconciler.Reconciler.set_viewport_size].
 
+        Subtrees whose props and children are unchanged since the last
+        pass keep their cached `LayoutNode` objects, which lets the
+        layout engine reuse memoized measurements instead of re-running
+        flex math (see ``pythonnative.layout``). Only frames that
+        differ from the previously applied frame produce `SetFrameOp`s.
+
         The root native view's *frame* is intentionally NOT touched:
         its position and size are owned by the screen host (iOS
         ``_sync_root_frame`` places it below the top safe-area
-        inset; Android attaches it with ``MATCH_PARENT``). Calling
-        ``set_frame(root, 0, 0, w, h)`` here would silently reset
-        the iOS root's ``y`` from ``insets.top`` back to ``0``,
-        causing the root view to overlap the status bar / dynamic
-        island after every tab switch.
+        inset; Android attaches it with ``MATCH_PARENT``). Framing
+        the root here would silently reset the iOS root's ``y`` from
+        ``insets.top`` back to ``0``, causing the root view to overlap
+        the status bar / dynamic island after every tab switch.
         """
         if self._tree is None:
             return
         viewport_w, viewport_h = self._viewport_size
         if viewport_w <= 0 or viewport_h <= 0:
-            self._log_viewport(f"_run_layout: skipped empty viewport=({viewport_w},{viewport_h})")
             return
 
         self._layout_pass += 1
-        layout_pass = self._layout_pass
-        self._log_viewport(
-            f"_run_layout: pass#{layout_pass} start viewport=({viewport_w},{viewport_h}) "
-            f"root={self._node_debug(self._tree)}"
-        )
-        layout_root = self._build_layout_tree(self._tree)
+        layout_root = self._build_layout_tree_cached(self._tree)
         if layout_root is None:
-            self._log_viewport(f"_run_layout: pass#{layout_pass} no layout root")
             return
 
-        self._log_viewport(
-            f"_run_layout: pass#{layout_pass} layout root built children={len(layout_root.children)} "
-            f"style={layout_root.style!r}"
-        )
         viewport = LayoutNode(
             style={"width": viewport_w, "height": viewport_h},
             children=[layout_root],
         )
-        self._log_viewport(f"_run_layout: pass#{layout_pass} calling calculate_layout")
+        viewport.dirty = True
         calculate_layout(viewport, viewport_w, viewport_h)
-        self._log_viewport(
-            f"_run_layout: pass#{layout_pass} calculate_layout done "
-            f"root_size=({layout_root.width:.1f},{layout_root.height:.1f})"
-        )
         # Skip set_frame for the root itself — descendants are
         # positioned relative to the root's local origin, which is
         # what they want regardless of where the host placed the
         # root in the screen.
         for child in layout_root.children:
-            self._apply_layout(child, 0.0, 0.0)
+            self._collect_frames(child, 0.0, 0.0)
         # Lay out the children of every visible ``Modal`` as a fresh
         # subtree sized to the viewport. Modals are excluded from the
         # main layout tree (their content lives in a separately
@@ -1087,7 +1123,7 @@ class Reconciler:
         # children's frames never get computed and the modal renders
         # blank.
         self._layout_visible_modals(self._tree, viewport_w, viewport_h)
-        self._log_viewport(f"_run_layout: pass#{layout_pass} done")
+        self._clear_layout_dirty(self._tree)
 
     def _layout_visible_modals(
         self,
@@ -1106,24 +1142,102 @@ class Reconciler:
                     )
                     calculate_layout(viewport, viewport_w, viewport_h)
                     for c in viewport.children:
-                        self._apply_layout(c, 0.0, 0.0)
+                        self._collect_frames(c, 0.0, 0.0)
             return
         for child in vnode.children:
             self._layout_visible_modals(child, viewport_w, viewport_h)
 
+    def _build_layout_tree_cached(self, vnode: VNode) -> Optional[LayoutNode]:
+        """Like `_build_layout_tree` but reuses cached subtrees when clean.
+
+        A VNode's cached `LayoutNode` is reused when the node itself is
+        layout-clean and every child produced its cached node too (i.e.
+        the whole subtree is untouched). Reused nodes keep
+        ``dirty=False`` so the layout engine can serve their sizes from
+        its measurement memo; rebuilt nodes are flagged dirty, which
+        forces fresh flex math along the changed path.
+        """
+        element = vnode.element
+        if not isinstance(element.type, str) or element.type in (
+            "__Provider__",
+            "__ErrorBoundary__",
+            "__Fragment__",
+        ):
+            return self._build_layout_tree_cached(vnode.children[0]) if vnode.children else None
+        if element.type == "Modal":
+            return None  # Off-screen placeholder; not part of the visible flow.
+
+        child_layouts: List[LayoutNode] = []
+        for child_vnode in vnode.children:
+            child_layout = self._build_layout_tree_cached(child_vnode)
+            if child_layout is not None:
+                child_layouts.append(child_layout)
+
+        cached = vnode._layout_node
+        if cached is not None and not vnode._layout_dirty:
+            cached_children = self._direct_child_layouts(cached, element)
+            if len(cached_children) == len(child_layouts) and all(
+                a is b for a, b in zip(cached_children, child_layouts)
+            ):
+                return cached
+
+        layout = LayoutNode(style=extract_layout_style(element.props), user_data=vnode)
+        layout.dirty = True
+        if element.type == "ScrollView":
+            # Mark the scroll axis so the layout engine clamps the
+            # container's own main-axis size to its parent's available
+            # space (otherwise the container grows to fit its content
+            # and there is no overflow for the native ScrollView to
+            # actually scroll). The children are still wrapped below so
+            # they see an unbounded main axis when measured.
+            scroll_axis = element.props.get("scroll_axis", "vertical")
+            layout._pn_scroll_axis = "x" if scroll_axis == "horizontal" else "y"
+
+        if not vnode.children:
+            measure = self._make_measure_callback(vnode)
+            if measure is not None:
+                layout.measure = measure
+
+        for child_layout in child_layouts:
+            if element.type == "ScrollView":
+                axis = element.props.get("scroll_axis", "vertical")
+                child_layout = self._wrap_scroll_axis(child_layout, axis="x" if axis == "horizontal" else "y")
+                child_layout.dirty = True
+            layout.children.append(child_layout)
+
+        vnode._layout_node = layout
+        return layout
+
+    @staticmethod
+    def _direct_child_layouts(layout: LayoutNode, element: Element) -> List[LayoutNode]:
+        """Return the cached child layout nodes, unwrapping ScrollView wrappers."""
+        if element.type == "ScrollView":
+            out: List[LayoutNode] = []
+            for wrapper in layout.children:
+                out.extend(wrapper.children)
+            return out
+        return list(layout.children)
+
+    def _clear_layout_dirty(self, vnode: VNode) -> None:
+        vnode._layout_dirty = False
+        node = vnode._layout_node
+        if node is not None:
+            node.dirty = False
+            for wrapper_or_child in node.children:
+                wrapper_or_child.dirty = False
+        for child in vnode.children:
+            self._clear_layout_dirty(child)
+
     def _build_layout_tree(self, vnode: VNode) -> Optional[LayoutNode]:
-        """Walk `vnode` and build a parallel `LayoutNode` tree of native nodes.
+        """Build a fresh (uncached) `LayoutNode` tree for ``vnode``.
 
+        Used for Modal content (laid out against the viewport each
+        pass) and by
+        [`compute_layout_for_test`][pythonnative.reconciler.Reconciler.compute_layout_for_test].
         Function components, providers, and error boundaries are
         transparent: they delegate to their (single) child. Native
         nodes contribute a `LayoutNode` whose ``user_data`` points
         back to the VNode so the layout pass can apply frames.
-
-        Leaves whose intrinsic size depends on content (Text, Button,
-        Image, TextInput) get a measure callback that delegates to
-        the backend's ``measure_intrinsic``. ScrollView wraps its
-        single child in a synthetic node that strips the scrollable
-        axis bound, allowing the child to grow beyond the viewport.
         """
         element = vnode.element
         if not isinstance(element.type, str):
@@ -1131,29 +1245,19 @@ class Reconciler:
         if element.type in ("__Provider__", "__ErrorBoundary__", "__Fragment__"):
             return self._build_layout_tree(vnode.children[0]) if vnode.children else None
         if element.type == "Modal":
-            return None  # Off-screen placeholder; not part of the visible flow.
+            return None
 
         style = extract_layout_style(element.props)
         layout = LayoutNode(style=style, user_data=vnode)
+        layout.dirty = True
         if element.type == "ScrollView":
-            # Mark the scroll axis so the layout engine clamps the
-            # container's own main-axis size to its parent's available
-            # space (otherwise the container grows to fit its content
-            # and there is no overflow for the native ScrollView to
-            # actually scroll). The children are still wrapped below so
-            # they see an unbounded main axis when measured.
             scroll_axis = element.props.get("scroll_axis", "vertical")
             layout._pn_scroll_axis = "x" if scroll_axis == "horizontal" else "y"
-        self._log_viewport(
-            f"_build_layout_tree: node type={element.type!r} view={self._obj_debug(vnode.native_view)} "
-            f"style={style!r} children={len(vnode.children)}"
-        )
 
         if not vnode.children:
             measure = self._make_measure_callback(vnode)
             if measure is not None:
                 layout.measure = measure
-                self._log_viewport(f"_build_layout_tree: attached measure type={element.type!r}")
 
         for child_vnode in vnode.children:
             child_layout = self._build_layout_tree(child_vnode)
@@ -1163,10 +1267,8 @@ class Reconciler:
                 # ScrollView's child sees an unbounded main-axis viewport so it
                 # can size to its full content (the scrollable region).
                 axis = element.props.get("scroll_axis", "vertical")
-                if axis == "horizontal":
-                    child_layout = self._wrap_scroll_axis(child_layout, axis="x")
-                else:
-                    child_layout = self._wrap_scroll_axis(child_layout, axis="y")
+                child_layout = self._wrap_scroll_axis(child_layout, axis="x" if axis == "horizontal" else "y")
+                child_layout.dirty = True
             layout.children.append(child_layout)
 
         return layout
@@ -1177,93 +1279,61 @@ class Reconciler:
 
         Used by ScrollView to let its content grow beyond the viewport
         on the scroll axis. The wrapper is a transparent layout node
-        whose ``user_data`` is the child VNode (so frames still apply
-        correctly to the underlying native view).
+        whose ``user_data`` is ``None`` (frames still apply to the
+        underlying native views through the child's own node).
         """
         wrapper_style = {"flex_direction": "column"} if axis == "y" else {"flex_direction": "row"}
         wrapper = LayoutNode(style=wrapper_style, user_data=None)
         wrapper.children.append(child)
         return wrapper
 
-    _INTRINSIC_TYPES = frozenset(
-        {
-            "Text",
-            "Button",
-            "Image",
-            "TextInput",
-            "Switch",
-            "Slider",
-            "ProgressBar",
-            "ActivityIndicator",
-            "TabBar",
-            "Picker",
-        }
-    )
-
     def _make_measure_callback(self, vnode: VNode) -> Optional[Any]:
         """Return a measure callback for ``vnode`` if it has an intrinsic size."""
         type_name = vnode.element.type
         if type_name not in self._INTRINSIC_TYPES:
             return None
-        backend = self.backend
-        view = vnode.native_view
-        if view is None:
+        if vnode.tag is None:
             return None
-        node_label = self._node_debug(vnode)
+        backend = self.backend
 
         def measure(max_w: float, max_h: float) -> Tuple[float, float]:
             cache = vnode._measure_cache
-            if cache is not None and cache[0] is vnode.element and cache[1] == max_w and cache[2] == max_h:
-                self._log_viewport(f"measure: cache hit type={type_name!r} result=({cache[3]!r},{cache[4]!r})")
-                return (cache[3], cache[4])
+            if cache is not None and cache[0] == max_w and cache[1] == max_h:
+                return (cache[2], cache[3])
             try:
-                self._log_viewport(
-                    "measure: before backend.measure_intrinsic " f"{node_label} max=({max_w!r},{max_h!r})"
-                )
-                w, h = backend.measure_intrinsic(view, type_name, max_w, max_h)
+                w, h = backend.measure_intrinsic(vnode.tag, max_w, max_h)
                 result = (float(w), float(h))
-                self._log_viewport(f"measure: after backend.measure_intrinsic type={type_name!r} result={result!r}")
-                vnode._measure_cache = (vnode.element, max_w, max_h, result[0], result[1])
+                vnode._measure_cache = (max_w, max_h, result[0], result[1])
                 return result
-            except Exception as e:
-                self._log_viewport(
-                    "measure: backend.measure_intrinsic raised "
-                    f"type={type_name!r} {type(e).__name__}: {e!r}; fallback=(0,0)"
-                )
+            except Exception:
                 return (0.0, 0.0)
 
         return measure
 
-    def _apply_layout(self, layout_node: LayoutNode, parent_x: float = 0.0, parent_y: float = 0.0) -> None:
-        """Walk a positioned layout tree and call ``set_frame`` for each native view.
+    def _collect_frames(self, layout_node: LayoutNode, parent_x: float, parent_y: float) -> None:
+        """Walk a positioned layout tree and emit `SetFrameOp`s for changed frames.
 
         Coordinates accumulate through transparent wrapper nodes
         (e.g., the ScrollView axis wrapper) so the underlying native
         view receives its position relative to its true native parent.
         """
         vnode = layout_node.user_data
-        if vnode is not None and vnode.native_view is not None:
-            try:
-                self._log_viewport(
-                    "apply_layout: before set_frame "
-                    f"{self._node_debug(vnode)} frame=("
-                    f"{layout_node.x + parent_x:.1f},{layout_node.y + parent_y:.1f},"
-                    f"{layout_node.width:.1f},{layout_node.height:.1f})"
-                )
-                self.backend.set_frame(
-                    vnode.native_view,
-                    vnode.element.type,
-                    layout_node.x + parent_x,
-                    layout_node.y + parent_y,
-                    layout_node.width,
-                    layout_node.height,
-                )
-                self._log_viewport(f"apply_layout: after set_frame type={vnode.element.type!r}")
-            except Exception as e:
-                self._log_viewport(
-                    "apply_layout: set_frame raised " f"type={vnode.element.type!r} {type(e).__name__}: {e!r}"
-                )
-                pass
+        if vnode is not None and vnode.tag is not None:
+            frame = (
+                layout_node.x + parent_x,
+                layout_node.y + parent_y,
+                layout_node.width,
+                layout_node.height,
+            )
+            if vnode._last_frame != frame:
+                vnode._last_frame = frame
+                self._ops.append(SetFrameOp(vnode.tag, frame[0], frame[1], frame[2], frame[3]))
+                # Mirror the frame into the element's ref (if any) so
+                # Python code can read measured geometry without a
+                # native round-trip (used by FlatList's virtualization).
+                ref = vnode.element.props.get("ref") if vnode.element.props else None
+                if isinstance(ref, dict):
+                    ref["_pn_frame"] = frame
             child_offset_x = 0.0
             child_offset_y = 0.0
         else:
@@ -1271,7 +1341,7 @@ class Reconciler:
             child_offset_y = layout_node.y + parent_y
 
         for child in layout_node.children:
-            self._apply_layout(child, child_offset_x, child_offset_y)
+            self._collect_frames(child, child_offset_x, child_offset_y)
 
     # ------------------------------------------------------------------
     # Test / debug accessor