pythonnative 0.25.0__py3-none-any.whl → 0.27.0__py3-none-any.whl

pythonnative/native_views/ios.py

@@ -14,20 +14,38 @@ is forwarded through
 view's reconciler-assigned tag.
 
 **Layout** is owned by the pure-Python flex engine in
-`pythonnative.layout`: container handlers create plain `UIView`s, the
-engine computes per-child frames in points, and
+`pythonnative.layout`: container handlers create hit-test-aware
+``UIView`` subclasses (see ``_PNInteractiveViewCTypes``), the engine
+computes per-child frames in points, and
 [`set_frame`][pythonnative.native_views.ios.IOSViewHandler.set_frame]
 applies those frames via UIKit's classic ``frame`` property (with Auto
 Layout disabled).
 
 **Gestures** attach real ``UIGestureRecognizer`` instances (pan, pinch,
-rotation, tap, long-press, swipe) configured from the serialized
-gesture specs, so recognition runs fully natively.
+rotation, tap, long-press, swipe, fling) configured from the
+serialized gesture specs, so recognition runs fully natively. The
+composition metadata emitted by
+[`serialize_gestures`][pythonnative.gestures.serialize_gestures] is
+honored natively too: the shared delegate answers
+``shouldRecognizeSimultaneously...`` from each spec's
+``"simultaneous"`` set, and ``"wait_for"`` relationships map onto
+``requireGestureRecognizerToFail:``.
+
+**Interaction props**: ``pointer_events`` and ``hit_slop`` are
+implemented by overriding ``pointInside:withEvent:`` and
+``hitTest:withEvent:`` on the container subclass; ``z_index`` maps to
+``layer.zPosition``. Per-corner radii (``border_top_left_radius`` and
+friends) use ``layer.maskedCorners`` when one radius is shared and a
+``CAShapeLayer`` mask when radii differ.
 
 **Animations**: ``timing`` and ``spring`` specs are driven by UIKit
 block animations with completion callbacks reported back through
 ``pythonnative.animated.native_animation_completed``; ``decay`` falls
-back to the Python ticker.
+back to the Python ticker. Python-driven frames arriving through
+``set_animated_property`` accept floats for opacity and transform
+channels, numeric degrees for ``rotate``, and ``"#RRGGBB"`` /
+``"#AARRGGBB"`` strings for ``background_color`` and ``color``;
+unknown properties are ignored.
 
 This module is only imported on iOS at runtime. Desktop tests inject a
 mock registry via
@@ -42,6 +60,7 @@ from typing import Any, Callable, Dict, List, Optional, Tuple
 
 from rubicon.objc import SEL, ObjCClass, ObjCInstance, objc_method
 
+from .. import diagnostics
 from ..events import dispatch_event, event_names
 from . import _tripwire_log
 from .base import ViewHandler, _safe_max, parse_color_int
@@ -80,7 +99,7 @@ try:
     _UIView = ObjCClass("UIView")
     _UIView.declare_property("superview")
 except Exception:
-    pass
+    diagnostics.swallowed("ios.<module>")
 
 
 def _objc_ptr(obj: Any) -> Optional[int]:
@@ -204,6 +223,10 @@ _add_method = _libobjc.class_addMethod
 _add_method.restype = _ct.c_bool
 _add_method.argtypes = [_ct.c_void_p, _ct.c_void_p, _ct.c_void_p, _ct.c_char_p]
 
+_get_method_imp = _libobjc.class_getMethodImplementation
+_get_method_imp.restype = _ct.c_void_p
+_get_method_imp.argtypes = [_ct.c_void_p, _ct.c_void_p]
+
 _objc_msgSend = _libobjc.objc_msgSend
 
 _SEL_ALLOC = _sel_reg(b"alloc")
@@ -225,6 +248,11 @@ _SEL_TEXT_VIEW_DID_END = _sel_reg(b"textViewDidEndEditing:")
 _SEL_TEXT_VIEW_DID_CHANGE = _sel_reg(b"textViewDidChange:")
 
 _NS_OBJECT_CLS = _get_cls(b"NSObject")
+_UIVIEW_CLS = _get_cls(b"UIView")
+
+
+class _PNCGPoint(_ct.Structure):
+    _fields_ = [("x", _ct.c_double), ("y", _ct.c_double)]
 
 
 # ======================================================================
@@ -267,17 +295,17 @@ def _apply_border(layer: Any, props: Dict[str, Any]) -> None:
             # asks for corners (matches iOS UIKit common practice).
             layer.setMasksToBounds_(True)
         except Exception:
-            pass
+            diagnostics.swallowed("ios._apply_border")
     if "border_width" in props and props["border_width"] is not None:
         try:
             layer.setBorderWidth_(float(props["border_width"]))
         except Exception:
-            pass
+            diagnostics.swallowed("ios._apply_border")
     if "border_color" in props and props["border_color"] is not None:
         try:
             layer.setBorderColor_(_cgcolor(props["border_color"]))
         except Exception:
-            pass
+            diagnostics.swallowed("ios._apply_border")
 
 
 def _apply_view_border(view: Any, props: Dict[str, Any]) -> None:
@@ -294,13 +322,13 @@ def _apply_view_border(view: Any, props: Dict[str, Any]) -> None:
                 if width > 0.0 and height > 0.0:
                     radius = min(requested, min(width, height) / 2.0)
             except Exception:
-                pass
+                diagnostics.swallowed("ios._apply_view_border")
             border_props = dict(props)
             border_props["border_radius"] = radius
             _apply_border(view.layer, border_props)
             return
         except Exception:
-            pass
+            diagnostics.swallowed("ios._apply_view_border")
     _apply_border(view.layer, props)
 
 
@@ -344,7 +372,7 @@ def _apply_side_borders(view: Any, props: Dict[str, Any]) -> None:
     try:
         view.layer.setBorderWidth_(0.0)
     except Exception:
-        pass
+        diagnostics.swallowed("ios._apply_side_borders")
     try:
         bounds = view.bounds
         w = float(bounds.size.width)
@@ -352,7 +380,7 @@ def _apply_side_borders(view: Any, props: Dict[str, Any]) -> None:
         if w > 0.0 and h > 0.0:
             _update_side_border_layers(view, w, h)
     except Exception:
-        pass
+        diagnostics.swallowed("ios._apply_side_borders")
 
 
 def _update_side_border_layers(view: Any, width: float, height: float) -> None:
@@ -377,7 +405,7 @@ def _update_side_border_layers(view: Any, width: float, height: float) -> None:
                 try:
                     layer.removeFromSuperlayer()
                 except Exception:
-                    pass
+                    diagnostics.swallowed("ios._update_side_border_layers")
                 layers[i] = None
             continue
         try:
@@ -388,7 +416,7 @@ def _update_side_border_layers(view: Any, width: float, height: float) -> None:
             layer.setBackgroundColor_(_cgcolor(entry["colors"][i]))
             layer.setFrame_(frames[i])
         except Exception:
-            pass
+            diagnostics.swallowed("ios._update_side_border_layers")
 
 
 def _clamp_view_corner_radius(view: Any, width: float, height: float) -> None:
@@ -402,7 +430,7 @@ def _clamp_view_corner_radius(view: Any, width: float, height: float) -> None:
     try:
         view.layer.setCornerRadius_(min(float(requested), max_radius))
     except Exception:
-        pass
+        diagnostics.swallowed("ios._clamp_view_corner_radius")
 
 
 def _clamp_layer_corner_radius(layer: Any, width: float, height: float) -> None:
@@ -418,7 +446,140 @@ def _clamp_layer_corner_radius(layer: Any, width: float, height: float) -> None:
     try:
         layer.setCornerRadius_(min(requested, max_radius))
     except Exception:
-        pass
+        diagnostics.swallowed("ios._clamp_layer_corner_radius")
+
+
+# ----------------------------------------------------------------------
+# Per-corner radii
+# ----------------------------------------------------------------------
+#
+# When every rounded corner shares one radius the cheap path applies:
+# ``layer.cornerRadius`` restricted to the rounded corners through
+# ``layer.maskedCorners``. When the radii differ, UIKit has no direct
+# API, so the view's layer gets a ``CAShapeLayer`` mask built from a
+# ``UIBezierPath`` with one arc per corner; the mask depends on the
+# view's bounds, so ``set_frame`` rebuilds it on every frame change via
+# ``_update_corner_mask``.
+
+# Order matches ``_MASKED_CORNER_BITS``: top-left, top-right,
+# bottom-left, bottom-right.
+_CORNER_RADIUS_KEYS = (
+    "border_top_left_radius",
+    "border_top_right_radius",
+    "border_bottom_left_radius",
+    "border_bottom_right_radius",
+)
+# CACornerMask bits: kCALayerMinXMinYCorner (top-left) = 1,
+# MaxXMinY (top-right) = 2, MinXMaxY (bottom-left) = 4,
+# MaxXMaxY (bottom-right) = 8.
+_MASKED_CORNER_BITS = (1, 2, 4, 8)
+_ALL_MASKED_CORNERS = 15
+
+# id(view) -> (tl, tr, bl, br) radii for views on the shape-mask path.
+_pn_corner_radii_map: dict = {}
+
+
+def _apply_corner_radii(view: Any, merged: Dict[str, Any]) -> None:
+    """Apply per-corner radii from the *merged* prop set.
+
+    Unspecified corners inherit the uniform ``border_radius`` (else 0),
+    matching the Android backend. With every per-corner key absent the
+    entry is dropped and the uniform path owns the corners again.
+    """
+    if not any(merged.get(k) is not None for k in _CORNER_RADIUS_KEYS):
+        if _pn_corner_radii_map.pop(id(view), None) is not None:
+            try:
+                view.layer.setMask_(None)
+                view.layer.setMaskedCorners_(_ALL_MASKED_CORNERS)
+            except Exception:
+                diagnostics.swallowed("ios._apply_corner_radii")
+            _apply_view_border(view, merged)
+        return
+    base = float(merged.get("border_radius") or 0.0)
+    radii = tuple(
+        max(0.0, _safe_finite(merged[k], base)) if merged.get(k) is not None else max(0.0, base)
+        for k in _CORNER_RADIUS_KEYS
+    )
+    distinct = {r for r in radii if r > 0.0}
+    if len(distinct) <= 1:
+        # One shared radius (or all zero): plain cornerRadius limited
+        # to the rounded corners.
+        _pn_corner_radii_map.pop(id(view), None)
+        value = distinct.pop() if distinct else 0.0
+        mask = 0
+        for bit, r in zip(_MASKED_CORNER_BITS, radii):
+            if r > 0.0:
+                mask |= bit
+        try:
+            view.layer.setMask_(None)
+            view.layer.setCornerRadius_(value)
+            view.layer.setMaskedCorners_(mask if mask else _ALL_MASKED_CORNERS)
+            view.layer.setMasksToBounds_(True)
+        except Exception:
+            diagnostics.swallowed("ios._apply_corner_radii")
+        # Route the shared value through the frame-time pill clamp.
+        _pn_view_border_radius_map[id(view)] = value
+        return
+    # Differing radii: shape-layer mask, rebuilt at frame time.
+    _pn_view_border_radius_map.pop(id(view), None)
+    _pn_corner_radii_map[id(view)] = radii
+    try:
+        view.layer.setCornerRadius_(0.0)
+        view.layer.setMaskedCorners_(_ALL_MASKED_CORNERS)
+    except Exception:
+        diagnostics.swallowed("ios._apply_corner_radii")
+    try:
+        bounds = view.bounds
+        w = float(bounds.size.width)
+        h = float(bounds.size.height)
+        if w > 0.0 and h > 0.0:
+            _update_corner_mask(view, w, h)
+    except Exception:
+        diagnostics.swallowed("ios._apply_corner_radii")
+
+
+def _update_corner_mask(view: Any, width: float, height: float) -> None:
+    """(Re)build the CAShapeLayer corner mask for the current bounds."""
+    radii = _pn_corner_radii_map.get(id(view))
+    if radii is None or width <= 0.0 or height <= 0.0:
+        return
+    tl, tr, bl, br = radii
+    # CSS-style scaling so adjacent radii never overlap along an edge.
+    scale = 1.0
+    for pair_sum, extent in ((tl + tr, width), (bl + br, width), (tl + bl, height), (tr + br, height)):
+        if pair_sum > extent > 0.0:
+            scale = min(scale, extent / pair_sum)
+    tl, tr, bl, br = (r * scale for r in radii)
+    try:
+        path = ObjCClass("UIBezierPath").bezierPath()
+        half_pi = math.pi / 2.0
+        path.moveToPoint_((tl, 0.0))
+        path.addLineToPoint_((width - tr, 0.0))
+        if tr > 0.0:
+            path.addArcWithCenter_radius_startAngle_endAngle_clockwise_((width - tr, tr), tr, -half_pi, 0.0, True)
+        path.addLineToPoint_((width, height - br))
+        if br > 0.0:
+            path.addArcWithCenter_radius_startAngle_endAngle_clockwise_(
+                (width - br, height - br), br, 0.0, half_pi, True
+            )
+        path.addLineToPoint_((bl, height))
+        if bl > 0.0:
+            path.addArcWithCenter_radius_startAngle_endAngle_clockwise_((bl, height - bl), bl, half_pi, math.pi, True)
+        path.addLineToPoint_((0.0, tl))
+        if tl > 0.0:
+            path.addArcWithCenter_radius_startAngle_endAngle_clockwise_((tl, tl), tl, math.pi, math.pi + half_pi, True)
+        path.closePath()
+        # On raw-registered outbound wrappers rubicon sometimes resolves
+        # ``CGPath`` as a bound method rather than a property.
+        cgpath = path.CGPath
+        if callable(cgpath):
+            cgpath = cgpath()
+        shape = ObjCClass("CAShapeLayer").layer()
+        shape.setFrame_(((0.0, 0.0), (width, height)))
+        shape.setPath_(cgpath)
+        view.layer.setMask_(shape)
+    except Exception:
+        diagnostics.swallowed("ios._update_corner_mask")
 
 
 def _apply_shadow(view: Any, props: Dict[str, Any]) -> None:
@@ -434,22 +595,22 @@ def _apply_shadow(view: Any, props: Dict[str, Any]) -> None:
             layer.setMasksToBounds_(False)
             view.setClipsToBounds_(False)
         except Exception:
-            pass
+            diagnostics.swallowed("ios._apply_shadow")
     if "shadow_color" in props and props["shadow_color"] is not None:
         try:
             layer.setShadowColor_(_cgcolor(props["shadow_color"]))
         except Exception:
-            pass
+            diagnostics.swallowed("ios._apply_shadow")
     if "shadow_opacity" in props and props["shadow_opacity"] is not None:
         try:
             layer.setShadowOpacity_(float(props["shadow_opacity"]))
         except Exception:
-            pass
+            diagnostics.swallowed("ios._apply_shadow")
     if "shadow_radius" in props and props["shadow_radius"] is not None:
         try:
             layer.setShadowRadius_(float(props["shadow_radius"]))
         except Exception:
-            pass
+            diagnostics.swallowed("ios._apply_shadow")
     if "shadow_offset" in props and props["shadow_offset"] is not None:
         offset = props["shadow_offset"]
         try:
@@ -460,7 +621,7 @@ def _apply_shadow(view: Any, props: Dict[str, Any]) -> None:
                 w, h = float(offset[0]), float(offset[1])
             layer.setShadowOffset_((w, h))
         except Exception:
-            pass
+            diagnostics.swallowed("ios._apply_shadow")
 
 
 def _make_transform(spec: Any) -> Any:
@@ -534,7 +695,7 @@ def _apply_transform(view: Any, props: Dict[str, Any]) -> None:
         try:
             view.setTransform_((1.0, 0.0, 0.0, 1.0, 0.0, 0.0))
         except Exception:
-            pass
+            diagnostics.swallowed("ios._apply_transform")
         return
     try:
         transform = _make_transform(spec)
@@ -565,7 +726,7 @@ def _apply_transform(view: Any, props: Dict[str, Any]) -> None:
         # rubicon-objc accepts the C struct as a tuple of its fields.
         view.setTransform_((a, b, c, d, tx, ty))
     except Exception:
-        pass
+        diagnostics.swallowed("ios._apply_transform")
 
 
 # UIAccessibilityTraits bitmask values (UIKit constants).
@@ -604,25 +765,25 @@ def _apply_accessibility(view: Any, props: Dict[str, Any]) -> None:
         try:
             view.setIsAccessibilityElement_(bool(props["accessible"]))
         except Exception:
-            pass
+            diagnostics.swallowed("ios._apply_accessibility")
     if "accessibility_label" in props:
         v = props["accessibility_label"]
         try:
             view.setAccessibilityLabel_(str(v) if v is not None else "")
         except Exception:
-            pass
+            diagnostics.swallowed("ios._apply_accessibility")
     if "accessibility_hint" in props:
         v = props["accessibility_hint"]
         try:
             view.setAccessibilityHint_(str(v) if v is not None else "")
         except Exception:
-            pass
+            diagnostics.swallowed("ios._apply_accessibility")
     if "test_id" in props:
         v = props["test_id"]
         try:
             view.setAccessibilityIdentifier_(str(v) if v is not None else None)
         except Exception:
-            pass
+            diagnostics.swallowed("ios._apply_accessibility")
 
     role = props.get("accessibility_role")
     state = props.get("accessibility_state")
@@ -642,11 +803,11 @@ def _apply_accessibility(view: Any, props: Dict[str, Any]) -> None:
             try:
                 view.setAccessibilityValue_("expanded" if state["expanded"] else "collapsed")
             except Exception:
-                pass
+                diagnostics.swallowed("ios._apply_accessibility")
     try:
         view.setAccessibilityTraits_(traits)
     except Exception:
-        pass
+        diagnostics.swallowed("ios._apply_accessibility")
 
 
 def _apply_common_visual(view: Any, props: Dict[str, Any]) -> None:
@@ -657,21 +818,242 @@ def _apply_common_visual(view: Any, props: Dict[str, Any]) -> None:
         try:
             view.layer.setBackgroundColor_(color.CGColor)
         except Exception:
-            pass
+            diagnostics.swallowed("ios._apply_common_visual")
     if "overflow" in props:
         view.setClipsToBounds_(props["overflow"] == "hidden")
     if "opacity" in props and props["opacity"] is not None:
         try:
             view.setAlpha_(float(props["opacity"]))
         except Exception:
-            pass
+            diagnostics.swallowed("ios._apply_common_visual")
+    if "z_index" in props:
+        # A removed prop (None) restores the default plane.
+        try:
+            z = props["z_index"]
+            view.layer.setZPosition_(float(z) if z is not None else 0.0)
+        except Exception:
+            diagnostics.swallowed("ios._apply_common_visual")
+    if "pointer_events" in props or "hit_slop" in props:
+        _apply_interaction_props(view, props)
     _apply_view_border(view, props)
     _apply_side_borders(view, props)
+    # Per-corner radii read the merged prop set (an update may carry
+    # only one key); a lone border_radius change must also re-run the
+    # per-corner path when corner keys are active, or the uniform
+    # applier above would stomp the masked corners.
+    merged = _state_of(view).get("props") or props
+    if any(k in props for k in _CORNER_RADIUS_KEYS) or (
+        "border_radius" in props and any(merged.get(k) is not None for k in _CORNER_RADIUS_KEYS)
+    ):
+        _apply_corner_radii(view, merged)
     _apply_shadow(view, props)
     _apply_transform(view, props)
     _apply_accessibility(view, props)
 
 
+# ======================================================================
+# Interaction props: pointer_events / hit_slop (raw libobjc subclass)
+# ======================================================================
+#
+# ``pointer_events`` and ``hit_slop`` need to change how UIKit
+# hit-tests a view, which requires overriding ``pointInside:withEvent:``
+# and ``hitTest:withEvent:``. Like ``_PNPortalViewCTypes``, the
+# ``_PNInteractiveViewCTypes`` class is registered with raw libobjc
+# (CFUNCTYPE IMPs) rather than rubicon's ``@objc_method``, for the same
+# arm64 FFI reliability reasons documented in the module header.
+#
+# Container handlers (View / Row / Column, Pressable, SafeAreaView,
+# KeyboardAvoidingView) *always* instantiate this subclass. That is the
+# low-risk choice: with no entry in ``_pn_interaction_state`` both
+# overrides reproduce stock UIView behavior exactly, and it means the
+# props can appear, change, or disappear on any later render without
+# recreating the view. Leaf handlers (labels, controls) keep their
+# stock classes; if the props show up there, ``_apply_interaction_props``
+# warns once and the props are ignored.
+#
+# The overrides read per-view state synchronously from
+# ``_pn_interaction_state``, a Python dict keyed by the raw view
+# pointer (the ``self`` of every IMP), following the same routing
+# pattern as ``_pn_action_handlers``.
+#
+# Semantics (matching React Native and the Android backend):
+#
+# - ``"none"``: the view and its whole subtree are transparent to
+#   touches (``hitTest`` returns nil, ``pointInside`` returns NO).
+# - ``"box_none"``: the view itself never receives touches, but
+#   subviews still do (``hitTest`` returns the subview result and
+#   converts a self result to nil).
+# - ``"box_only"``: the view receives touches, subviews never do.
+# - ``hit_slop`` expands ``pointInside`` by the slop on each edge.
+#   As on every platform, the expanded area only works where the
+#   parent's own bounds still contain the point.
+
+# Maps view ptr -> {"pointer_events": mode or None,
+#                   "hit_slop": (top, left, bottom, right) or None}.
+_pn_interaction_state: Dict[int, Dict[str, Any]] = {}
+
+_POINTER_EVENT_MODES = ("none", "box_none", "box_only")
+
+
+def _hit_slop_insets(value: Any) -> Optional[Tuple[float, float, float, float]]:
+    """Normalize a ``hit_slop`` prop into ``(top, left, bottom, right)`` points.
+
+    Accepts a uniform number or a dict with any of ``top`` / ``left`` /
+    ``bottom`` / ``right``. Returns ``None`` for absent or unparseable
+    values.
+    """
+    if value is None:
+        return None
+    if isinstance(value, dict):
+        try:
+            return (
+                float(value.get("top", 0.0) or 0.0),
+                float(value.get("left", 0.0) or 0.0),
+                float(value.get("bottom", 0.0) or 0.0),
+                float(value.get("right", 0.0) or 0.0),
+            )
+        except Exception:
+            return None
+    try:
+        uniform = float(value)
+    except Exception:
+        return None
+    return (uniform, uniform, uniform, uniform)
+
+
+_INTERACTIVE_POINT_INSIDE_TYPE = _ct.CFUNCTYPE(_ct.c_bool, _ct.c_void_p, _ct.c_void_p, _PNCGPoint, _ct.c_void_p)
+_INTERACTIVE_HITTEST_TYPE = _ct.CFUNCTYPE(_ct.c_void_p, _ct.c_void_p, _ct.c_void_p, _PNCGPoint, _ct.c_void_p)
+
+_SEL_HITTEST_WITH_EVENT = _sel_reg(b"hitTest:withEvent:")
+
+# UIView's own ``hitTest:withEvent:`` IMP, called directly (the
+# superclass is known to be exactly UIView, so this is equivalent to a
+# ``objc_msgSendSuper`` call without the extra struct plumbing). Bound
+# after the class registration below.
+_uiview_hittest_imp: Any = None
+
+
+def _interactive_point_inside_imp(self_ptr: int, _cmd_ptr: int, point: Any, _event_ptr: int) -> bool:
+    """``pointInside:withEvent:`` honoring pointer_events and hit_slop."""
+    try:
+        info = _pn_interaction_state.get(int(self_ptr or 0)) or {}
+        if info.get("pointer_events") == "none":
+            return False
+        top = left = bottom = right = 0.0
+        slop = info.get("hit_slop")
+        if slop is not None:
+            top, left, bottom, right = slop
+        view = ObjCInstance(_ct.c_void_p(self_ptr))
+        bounds = view.bounds
+        w = float(bounds.size.width)
+        h = float(bounds.size.height)
+        px = float(point.x)
+        py = float(point.y)
+        return (-left <= px <= w + right) and (-top <= py <= h + bottom)
+    except Exception:
+        return False
+
+
+def _interactive_hittest_imp(self_ptr: int, _cmd_ptr: int, point: Any, event_ptr: int) -> int:
+    """``hitTest:withEvent:`` honoring the pointer_events mode.
+
+    Delegates to UIView's stock implementation (which consults our
+    ``pointInside:`` override, so hit_slop is already accounted for),
+    then filters the result per the mode.
+    """
+    try:
+        info = _pn_interaction_state.get(int(self_ptr or 0)) or {}
+        mode = info.get("pointer_events")
+        if mode == "none":
+            return 0
+        if _uiview_hittest_imp is None:
+            return 0
+        result = int(_uiview_hittest_imp(self_ptr, _SEL_HITTEST_WITH_EVENT, point, event_ptr) or 0)
+        if mode == "box_none" and result == int(self_ptr or 0):
+            return 0
+        if mode == "box_only":
+            return int(self_ptr or 0) if result else 0
+        return result
+    except Exception:
+        return 0
+
+
+_interactive_point_inside_imp_ref = _INTERACTIVE_POINT_INSIDE_TYPE(_interactive_point_inside_imp)
+_interactive_hittest_imp_ref = _INTERACTIVE_HITTEST_TYPE(_interactive_hittest_imp)
+
+_PN_INTERACTIVE_VIEW_CLS = _alloc_cls(_UIVIEW_CLS, b"_PNInteractiveViewCTypes", 0) if _UIVIEW_CLS else None
+if _PN_INTERACTIVE_VIEW_CLS:
+    _add_method(
+        _PN_INTERACTIVE_VIEW_CLS,
+        _sel_reg(b"pointInside:withEvent:"),
+        _ct.cast(_interactive_point_inside_imp_ref, _ct.c_void_p),
+        b"c@:{CGPoint=dd}@",
+    )
+    _add_method(
+        _PN_INTERACTIVE_VIEW_CLS,
+        _SEL_HITTEST_WITH_EVENT,
+        _ct.cast(_interactive_hittest_imp_ref, _ct.c_void_p),
+        b"@@:{CGPoint=dd}@",
+    )
+    _reg_cls(_PN_INTERACTIVE_VIEW_CLS)
+    try:
+        _raw_hittest = _get_method_imp(_UIVIEW_CLS, _SEL_HITTEST_WITH_EVENT)
+        if _raw_hittest:
+            _uiview_hittest_imp = _ct.cast(_ct.c_void_p(_raw_hittest), _INTERACTIVE_HITTEST_TYPE)
+    except Exception:
+        _uiview_hittest_imp = None
+
+
+def _new_container_view() -> Any:
+    """Instantiate the hit-test-aware container class (UIView fallback).
+
+    When the ``_PNInteractiveViewCTypes`` registration is unavailable
+    the container degrades to a plain ``UIView``: everything works
+    except ``pointer_events`` / ``hit_slop``, which warn when applied.
+    """
+    view = None
+    if _PN_INTERACTIVE_VIEW_CLS:
+        try:
+            view = ObjCClass("_PNInteractiveViewCTypes").alloc().init()
+        except Exception:
+            view = None
+    if view is None:
+        view = ObjCClass("UIView").alloc().init()
+    view.setTranslatesAutoresizingMaskIntoConstraints_(True)
+    return view
+
+
+def _apply_interaction_props(view: Any, props: Dict[str, Any]) -> None:
+    """Record pointer_events / hit_slop where the ObjC overrides read them."""
+    ptr = _objc_ptr(view)
+    if ptr is None:
+        return
+    entry = _pn_interaction_state.setdefault(ptr, {})
+    if "pointer_events" in props:
+        mode = props["pointer_events"]
+        entry["pointer_events"] = mode if mode in _POINTER_EVENT_MODES else None
+    if "hit_slop" in props:
+        entry["hit_slop"] = _hit_slop_insets(props["hit_slop"])
+    if entry.get("pointer_events") is None and entry.get("hit_slop") is None:
+        # Both props removed (or "auto"): drop the entry so the
+        # overrides take their stock-behavior fast path.
+        _pn_interaction_state.pop(ptr, None)
+        return
+    is_custom = False
+    try:
+        if _PN_INTERACTIVE_VIEW_CLS:
+            is_custom = bool(view.isKindOfClass_(ObjCClass("_PNInteractiveViewCTypes")))
+    except Exception:
+        is_custom = False
+    if not is_custom:
+        diagnostics.warn_once(
+            "pointer_events / hit_slop only work on container elements "
+            "(View, Row, Column, Pressable) on iOS; this element's native "
+            "class doesn't override hit-testing, so the props are ignored",
+            key=f"interaction_props:{_tag_of(view)}",
+        )
+
+
 # ======================================================================
 # Retention + shared targets
 # ======================================================================
@@ -683,17 +1065,42 @@ _pn_retained_views: list = []
 # Simultaneous-recognition gesture delegate (raw libobjc)
 # ======================================================================
 #
-# All PythonNative recognizers on a view should recognize together
-# (press feedback + pan + pinch...), matching the GestureArbiter's
-# semantics on Android/desktop. UIKit defaults to exclusivity, so every
-# recognizer we create gets this delegate, which answers YES to
-# ``gestureRecognizer:shouldRecognizeSimultaneouslyWithGestureRecognizer:``.
+# UIKit defaults to recognizer exclusivity, so every recognizer we
+# create gets this delegate. The answer to
+# ``gestureRecognizer:shouldRecognizeSimultaneouslyWithGestureRecognizer:``
+# mirrors the GestureArbiter's semantics on Android/desktop:
+#
+# - Recognizers wired by ``_wire_gestures`` carry an entry in
+#   ``_pn_gesture_relations`` (view pointer, spec index, and the spec's
+#   ``"simultaneous"`` index set). Two recognizers on the *same* view
+#   recognize together only when each is in the other's set; a spec
+#   without the key means "simultaneous with everything" (back-compat
+#   for hand-built spec dicts).
+# - Any pairing involving an unknown recognizer (Pressable's built-in
+#   press trio, a scroll view's pan, recognizers from another view)
+#   keeps the historical always-YES behavior.
 
 _GESTURE_SIMUL_TYPE = _ct.CFUNCTYPE(_ct.c_bool, _ct.c_void_p, _ct.c_void_p, _ct.c_void_p, _ct.c_void_p)
 
+# Maps recognizer ptr -> (view ptr, spec index, simultaneous set or None).
+_pn_gesture_relations: Dict[int, Tuple[int, int, Optional[frozenset]]] = {}
+
 
 def _gesture_simul_imp(self_ptr: int, cmd_ptr: int, g1_ptr: int, g2_ptr: int) -> bool:
-    return True
+    try:
+        a = _pn_gesture_relations.get(int(g1_ptr or 0))
+        b = _pn_gesture_relations.get(int(g2_ptr or 0))
+        if a is None or b is None:
+            return True
+        if a[0] != b[0]:
+            return True
+        sim_a = a[2]
+        sim_b = b[2]
+        if sim_a is None or sim_b is None:
+            return True
+        return b[1] in sim_a and a[1] in sim_b
+    except Exception:
+        return True
 
 
 _gesture_simul_imp_ref = _GESTURE_SIMUL_TYPE(_gesture_simul_imp)
@@ -733,7 +1140,7 @@ def _set_recognizer_delegate(recognizer: Any) -> None:
         rec_ptr = recognizer.ptr if hasattr(recognizer, "ptr") else recognizer
         _objc_msgSend(rec_ptr, _SEL_SET_DELEGATE, delegate)
     except Exception:
-        pass
+        diagnostics.swallowed("ios._set_recognizer_delegate")
 
 
 # ======================================================================
@@ -753,6 +1160,7 @@ def _set_recognizer_delegate(recognizer: Any) -> None:
 _pn_action_handlers: Dict[int, Any] = {}
 
 _ACTION_IMP_TYPE = _ct.CFUNCTYPE(None, _ct.c_void_p, _ct.c_void_p, _ct.c_void_p)
+_CONTROL_ACTION_IMP_TYPE = _ct.CFUNCTYPE(None, _ct.c_void_p, _ct.c_void_p, _ct.c_void_p, _ct.c_void_p)
 
 
 def _action_imp(_self_ptr: int, _cmd_ptr: int, sender_ptr: int) -> None:
@@ -763,12 +1171,70 @@ def _action_imp(_self_ptr: int, _cmd_ptr: int, sender_ptr: int) -> None:
     try:
         handler()
     except Exception:
-        pass
+        diagnostics.swallowed("ios._action_imp")
 
 
 _action_imp_ref = _ACTION_IMP_TYPE(_action_imp)
 
+# ----------------------------------------------------------------------
+# UIControl action dedupe
+# ----------------------------------------------------------------------
+#
+# The simulator's XCTest event-injection stack sometimes delivers a
+# single synthesized tap as *two* back-to-back "send control actions"
+# bursts for the same UIEvent (~1ms apart; the unified log shows one
+# UIEvent delivered to one window, then the doubled sends). Every
+# non-idempotent ``on_press`` then fires twice: reducer counters jump
+# by two, alerts present twice, pickers reopen after selecting. The
+# control action selector therefore takes the ``forEvent:`` argument
+# and drops a second send whose UIEvent timestamp matches the last one
+# delivered to the same control. Distinct taps (even rapid ones) carry
+# distinct event timestamps, and continuous ValueChanged streams
+# (slider drags) tick the timestamp per touch move, so only the
+# duplicated sends are filtered. Programmatic ``sendActions...`` calls
+# pass a nil event and are never deduped.
+
+# Maps control ptr -> UIEvent.timestamp of the last delivered action.
+_pn_last_control_event_ts: Dict[int, float] = {}
+
+_objc_msgSend_double = _ct.CFUNCTYPE(_ct.c_double, _ct.c_void_p, _ct.c_void_p)(("objc_msgSend", _libobjc))
+
+_SEL_TIMESTAMP = _sel_reg(b"timestamp")
+
+
+def _control_action_imp(_self_ptr: int, _cmd_ptr: int, sender_ptr: int, event_ptr: int) -> None:
+    """Raw C callback for every PythonNative UIControl event action."""
+    key = int(sender_ptr or 0)
+    handler = _pn_action_handlers.get(key)
+    if handler is None:
+        return
+    if event_ptr:
+        try:
+            timestamp = float(_objc_msgSend_double(event_ptr, _SEL_TIMESTAMP))
+        except Exception:
+            timestamp = None
+        if timestamp is not None:
+            if _pn_last_control_event_ts.get(key) == timestamp:
+                diagnostics.warn_once(
+                    "ios._control_action_imp dropped a duplicated control action "
+                    "(one UIEvent, two sends; a simulator event-injection quirk)",
+                    key=f"control_action_dedupe:{key}",
+                )
+                return
+            _pn_last_control_event_ts[key] = timestamp
+    try:
+        handler()
+    except Exception:
+        diagnostics.swallowed("ios._control_action_imp")
+
+
+_control_action_imp_ref = _CONTROL_ACTION_IMP_TYPE(_control_action_imp)
+
+# Gesture recognizers only support zero- or one-argument action
+# selectors, so recognizers keep the plain variant while controls use
+# the two-argument ``forEvent:`` variant for the dedupe above.
 _SEL_ON_ACTION = _sel_reg(b"onPNAction:")
+_SEL_ON_CONTROL_ACTION = _sel_reg(b"onPNControlAction:forEvent:")
 
 _PN_ACTION_TARGET_CLS = _alloc_cls(_NS_OBJECT_CLS, b"_PNActionTargetCTypes", 0)
 if _PN_ACTION_TARGET_CLS:
@@ -778,6 +1244,12 @@ if _PN_ACTION_TARGET_CLS:
         _ct.cast(_action_imp_ref, _ct.c_void_p),
         b"v@:@",
     )
+    _add_method(
+        _PN_ACTION_TARGET_CLS,
+        _SEL_ON_CONTROL_ACTION,
+        _ct.cast(_control_action_imp_ref, _ct.c_void_p),
+        b"v@:@@",
+    )
     _reg_cls(_PN_ACTION_TARGET_CLS)
 
 _pn_action_target_ptr: Any = None
@@ -830,7 +1302,7 @@ def _register_control_action(control: Any, events_mask: int, handler: Any) -> No
     _objc_msgSend.restype = None
     _objc_msgSend.argtypes = [_ct.c_void_p, _ct.c_void_p, _ct.c_void_p, _ct.c_ulong]
     ctl_ptr = control.ptr if hasattr(control, "ptr") else control
-    _objc_msgSend(ctl_ptr, _SEL_ADD_TARGET_ACTION_EVENTS, target_ptr, _SEL_ON_ACTION, events_mask)
+    _objc_msgSend(ctl_ptr, _SEL_ADD_TARGET_ACTION_EVENTS, target_ptr, _SEL_ON_CONTROL_ACTION, events_mask)
     _pn_action_handlers[_recognizer_ptr(control)] = handler
 
 
@@ -846,6 +1318,7 @@ def _make_gesture_handler(
     kind: str,
     index: int,
     direction: Optional[str] = None,
+    n_pointers: Optional[int] = None,
 ) -> Any:
     """Build the action closure emitting one ``gesture:<i>`` payload."""
 
@@ -864,11 +1337,11 @@ def _make_gesture_handler(
             payload["x"] = float(location.x)
             payload["y"] = float(location.y)
         except Exception:
-            pass
+            diagnostics.swallowed("ios._make_gesture_handler.handler")
         try:
             payload["pointer_count"] = int(rec.numberOfTouches)
         except Exception:
-            pass
+            diagnostics.swallowed("ios._make_gesture_handler.handler")
 
         if kind == "pan":
             try:
@@ -879,23 +1352,30 @@ def _make_gesture_handler(
                 payload["velocity_x"] = float(velocity.x)
                 payload["velocity_y"] = float(velocity.y)
             except Exception:
-                pass
+                diagnostics.swallowed("ios._make_gesture_handler.handler")
         elif kind == "pinch":
             try:
                 payload["scale"] = float(rec.scale)
             except Exception:
-                pass
+                diagnostics.swallowed("ios._make_gesture_handler.handler")
         elif kind == "rotation":
             try:
                 payload["rotation"] = float(rec.rotation)
             except Exception:
-                pass
+                diagnostics.swallowed("ios._make_gesture_handler.handler")
         elif kind == "swipe":
             # Discrete: UIKit only calls us on recognition, and only the
             # recognizer whose direction matched fires, so the bound
             # per-recognizer direction is the actual swipe direction.
             payload["state"] = "ended"
             payload["direction"] = direction
+        elif kind == "fling":
+            # Same discrete shape as swipe. ``numberOfTouches`` is often
+            # 0 by recognition time, so report the configured pointer
+            # requirement (which UIKit enforced) instead.
+            payload["state"] = "ended"
+            payload["direction"] = direction
+            payload["pointer_count"] = int(n_pointers or 1)
         elif kind == "tap":
             payload["state"] = "ended"
 
@@ -907,9 +1387,17 @@ def _make_gesture_handler(
 def _make_recognizer(kind: str, spec: Dict[str, Any]) -> List[Tuple[Any, Optional[str]]]:
     """Build the UIGestureRecognizer(s) for one serialized gesture spec.
 
-    Swipe with ``direction="any"`` needs one recognizer per direction
-    (UIKit constraint), so this returns ``(recognizer, direction)``
-    pairs; ``direction`` is ``None`` for non-swipe kinds.
+    Swipe and fling with ``direction="any"`` need one recognizer per
+    direction (a ``UISwipeGestureRecognizer`` reports no resolved
+    direction, only its configured mask), so this returns
+    ``(recognizer, direction)`` pairs; ``direction`` is ``None`` for
+    the other kinds.
+
+    Fling maps to ``UISwipeGestureRecognizer`` with
+    ``numberOfTouchesRequired``. The spec's ``min_velocity`` can't be
+    enforced: UIKit exposes no velocity knob on swipe recognizers, so
+    iOS uses the system's own swipe velocity threshold (a documented
+    approximation; Android and desktop honor the exact value).
     """
     out: List[Tuple[Any, Optional[str]]] = []
     if kind == "tap":
@@ -917,7 +1405,7 @@ def _make_recognizer(kind: str, spec: Dict[str, Any]) -> List[Tuple[Any, Optiona
         try:
             rec.setNumberOfTapsRequired_(max(1, int(spec.get("n_taps", 1))))
         except Exception:
-            pass
+            diagnostics.swallowed("ios._make_recognizer")
         out.append((rec, None))
     elif kind == "long_press":
         rec = ObjCClass("UILongPressGestureRecognizer").alloc().init()
@@ -925,14 +1413,14 @@ def _make_recognizer(kind: str, spec: Dict[str, Any]) -> List[Tuple[Any, Optiona
             rec.setMinimumPressDuration_(float(spec.get("min_duration_ms", 500.0)) / 1000.0)
             rec.setAllowableMovement_(float(spec.get("max_distance", 12.0)))
         except Exception:
-            pass
+            diagnostics.swallowed("ios._make_recognizer")
         out.append((rec, None))
     elif kind == "pan":
         rec = ObjCClass("UIPanGestureRecognizer").alloc().init()
         try:
             rec.setMinimumNumberOfTouches_(max(1, int(spec.get("min_pointers", 1))))
         except Exception:
-            pass
+            diagnostics.swallowed("ios._make_recognizer")
         out.append((rec, None))
     elif kind == "swipe":
         direction = str(spec.get("direction", "any"))
@@ -942,7 +1430,19 @@ def _make_recognizer(kind: str, spec: Dict[str, Any]) -> List[Tuple[Any, Optiona
             try:
                 rec.setDirection_(_SWIPE_DIRECTIONS[d])
             except Exception:
-                pass
+                diagnostics.swallowed("ios._make_recognizer")
+            out.append((rec, d))
+    elif kind == "fling":
+        direction = str(spec.get("direction", "any"))
+        directions = [direction] if direction in _SWIPE_DIRECTIONS else list(_SWIPE_DIRECTIONS)
+        n_pointers = max(1, int(spec.get("n_pointers", 1)))
+        for d in directions:
+            rec = ObjCClass("UISwipeGestureRecognizer").alloc().init()
+            try:
+                rec.setDirection_(_SWIPE_DIRECTIONS[d])
+                rec.setNumberOfTouchesRequired_(n_pointers)
+            except Exception:
+                diagnostics.swallowed("ios._make_recognizer")
             out.append((rec, d))
     elif kind == "pinch":
         out.append((ObjCClass("UIPinchGestureRecognizer").alloc().init(), None))
@@ -957,14 +1457,24 @@ def _wire_gestures(view: Any, specs: Any) -> None:
     Re-wiring on update removes previously attached PythonNative
     recognizers first (configuration changes are rare; correctness
     beats incremental patching here).
+
+    Composition metadata is applied in two passes: while creating each
+    recognizer its ``(view, index, simultaneous-set)`` triple is
+    recorded in ``_pn_gesture_relations`` for the shared delegate, and
+    once every recognizer exists, each spec's ``"wait_for"`` indices
+    are wired with ``requireGestureRecognizerToFail:`` (every
+    recognizer of the waiting spec requires every recognizer of each
+    target spec to fail; a spec can own several recognizers, e.g. an
+    any-direction swipe).
     """
     state = _state_of(view)
     for rec in state.get("gesture_recognizers") or []:
         try:
             view.removeGestureRecognizer_(rec)
         except Exception:
-            pass
+            diagnostics.swallowed("ios._wire_gestures")
         _pn_action_handlers.pop(_recognizer_ptr(rec), None)
+        _pn_gesture_relations.pop(_recognizer_ptr(rec), None)
     state["gesture_recognizers"] = []
     if not isinstance(specs, (list, tuple)) or not specs:
         return
@@ -972,20 +1482,25 @@ def _wire_gestures(view: Any, specs: Any) -> None:
     try:
         view.setUserInteractionEnabled_(True)
     except Exception:
-        pass
+        diagnostics.swallowed("ios._wire_gestures")
 
+    view_ptr = _objc_ptr(view) or 0
     recognizers: List[Any] = []
+    recs_by_index: Dict[int, List[Any]] = {}
     for i, spec in enumerate(specs):
         if not isinstance(spec, dict):
             continue
         kind = str(spec.get("kind", ""))
         if not kind:
             continue
+        sim = spec.get("simultaneous")
+        sim_set = None if sim is None else frozenset(int(s) for s in sim)
+        n_pointers = max(1, int(spec.get("n_pointers", 1) or 1)) if kind == "fling" else None
         for rec, direction in _make_recognizer(kind, spec):
             try:
                 rec.setCancelsTouchesInView_(False)
             except Exception:
-                pass
+                diagnostics.swallowed("ios._wire_gestures")
             _set_recognizer_delegate(rec)
             try:
                 view.addGestureRecognizer_(rec)
@@ -993,7 +1508,21 @@ def _wire_gestures(view: Any, specs: Any) -> None:
                 recognizers.append(rec)
             except Exception:
                 continue
-            _register_action(rec, _make_gesture_handler(rec, view, kind, i, direction))
+            _pn_gesture_relations[_recognizer_ptr(rec)] = (view_ptr, i, sim_set)
+            recs_by_index.setdefault(i, []).append(rec)
+            _register_action(rec, _make_gesture_handler(rec, view, kind, i, direction, n_pointers))
+
+    for i, spec in enumerate(specs):
+        if not isinstance(spec, dict):
+            continue
+        for target_index in spec.get("wait_for") or ():
+            targets = recs_by_index.get(int(target_index)) or []
+            for waiter in recs_by_index.get(i) or []:
+                for target in targets:
+                    try:
+                        waiter.requireGestureRecognizerToFail_(target)
+                    except Exception:
+                        diagnostics.swallowed("ios._wire_gestures")
 
     state["gesture_recognizers"] = recognizers
 
@@ -1010,6 +1539,16 @@ def _is_main_thread() -> bool:
 
 
 def _animated_applier_for(prop: str, value: Any) -> Optional[Callable[[Any], None]]:
+    """Build the per-frame applier for one animated property.
+
+    Color-valued frames (``background_color`` and ``color``) arrive as
+    ``"#RRGGBB"`` / ``"#AARRGGBB"`` strings from ``AnimatedInterpolation``
+    color outputs and go through the same ``_uicolor`` parsing the
+    ordinary update path uses. ``rotate`` receives numeric degrees,
+    which is what ``_apply_transform`` expects for bare numbers. An
+    unknown property returns ``None`` and the frame is silently
+    ignored.
+    """
     if prop == "opacity":
         v = float(value)
 
@@ -1022,6 +1561,18 @@ def _animated_applier_for(prop: str, value: Any) -> Optional[Callable[[Any], Non
         def _apply(view: Any) -> None:
             view.setBackgroundColor_(_uicolor(value))
 
+        return _apply
+    if prop == "color":
+
+        def _apply(view: Any) -> None:
+            color = _uicolor(value)
+            try:
+                view.setTextColor_(color)
+            except Exception:
+                # UIButton has no setTextColor:; views with neither
+                # selector raise into the caller's swallow.
+                view.setTitleColor_forState_(color, 0)
+
         return _apply
     if prop in ("translate_x", "translate_y", "scale", "scale_x", "scale_y", "rotate"):
         spec = {prop: value}
@@ -1082,13 +1633,13 @@ def _start_native_animation(view: Any, anim_id: int, prop_name: str, spec: Dict[
 
             native_animation_completed(anim_id, bool(finished))
         except Exception:
-            pass
+            diagnostics.swallowed("ios._start_native_animation._completion")
 
     def _animations() -> None:
         try:
             applier_to(view)
         except Exception:
-            pass
+            diagnostics.swallowed("ios._start_native_animation._animations")
 
     try:
         # Snap to the starting value so the animation covers the full
@@ -1163,15 +1714,19 @@ class IOSViewHandler(ViewHandler):
         state = _state_of(native_view)
         for rec in state.get("gesture_recognizers") or []:
             _pn_action_handlers.pop(_recognizer_ptr(rec), None)
+            _pn_gesture_relations.pop(_recognizer_ptr(rec), None)
         # Controls register their own pointer as the action-handler key
         # (see _register_control_action); drop it with the view.
         _pn_action_handlers.pop(_recognizer_ptr(native_view), None)
+        _pn_last_control_event_ts.pop(_recognizer_ptr(native_view), None)
+        _pn_interaction_state.pop(_objc_ptr(native_view) or 0, None)
         _pn_view_border_radius_map.pop(id(native_view), None)
+        _pn_corner_radii_map.pop(id(native_view), None)
         _pn_side_border_map.pop(id(native_view), None)
         try:
             native_view.removeFromSuperview()
         except Exception:
-            pass
+            diagnostics.swallowed("ios.IOSViewHandler.destroy")
         _forget(native_view)
 
     def _build(self, props: Dict[str, Any]) -> Any:
@@ -1187,7 +1742,7 @@ class IOSViewHandler(ViewHandler):
         try:
             child.setTranslatesAutoresizingMaskIntoConstraints_(True)
         except Exception:
-            pass
+            diagnostics.swallowed("ios.IOSViewHandler.insert_child")
         try:
             count = len(list(parent.subviews or []))
         except Exception:
@@ -1198,13 +1753,13 @@ class IOSViewHandler(ViewHandler):
             try:
                 parent.addSubview_(child)
             except Exception:
-                pass
+                diagnostics.swallowed("ios.IOSViewHandler.insert_child")
 
     def remove_child(self, parent: Any, child: Any) -> None:
         try:
             child.removeFromSuperview()
         except Exception:
-            pass
+            diagnostics.swallowed("ios.IOSViewHandler.remove_child")
 
     def set_frame(self, native_view: Any, x: float, y: float, width: float, height: float) -> None:
         if native_view is None:
@@ -1217,11 +1772,14 @@ class IOSViewHandler(ViewHandler):
             native_view.setTranslatesAutoresizingMaskIntoConstraints_(True)
             native_view.setFrame_(((frame_x, frame_y), (frame_w, frame_h)))
             _clamp_view_corner_radius(native_view, frame_w, frame_h)
+            # The per-corner shape mask is bounds-dependent; rebuild it
+            # whenever the frame changes.
+            _update_corner_mask(native_view, frame_w, frame_h)
             _update_side_border_layers(native_view, frame_w, frame_h)
             try:
                 _clamp_layer_corner_radius(native_view.layer, frame_w, frame_h)
             except Exception:
-                pass
+                diagnostics.swallowed("ios.IOSViewHandler.set_frame")
             try:
                 parent = native_view.superview
                 parent_cls = ""
@@ -1238,9 +1796,9 @@ class IOSViewHandler(ViewHandler):
                     content_h = max(float(bounds.size.height), frame_y + frame_h)
                     parent.setContentSize_((content_w, content_h))
             except Exception:
-                pass
+                diagnostics.swallowed("ios.IOSViewHandler.set_frame")
         except Exception:
-            pass
+            diagnostics.swallowed("ios.IOSViewHandler.set_frame")
 
     def measure_intrinsic(
         self,
@@ -1261,7 +1819,14 @@ class IOSViewHandler(ViewHandler):
             return (0.0, 0.0)
 
     def set_animated_property(self, native_view: Any, prop_name: str, value: Any) -> None:
-        """Apply one Python-driven animation frame immediately."""
+        """Apply one Python-driven animation frame immediately.
+
+        Accepts floats for ``opacity`` and the transform channels,
+        numeric degrees for ``rotate``, and ``"#RRGGBB"`` /
+        ``"#AARRGGBB"`` strings for ``background_color`` and ``color``
+        (see ``_animated_applier_for``). Unknown properties are
+        silently ignored.
+        """
         if native_view is None:
             return
         try:
@@ -1273,7 +1838,7 @@ class IOSViewHandler(ViewHandler):
         try:
             applier(native_view)
         except Exception:
-            pass
+            diagnostics.swallowed("ios.IOSViewHandler.set_animated_property")
 
     def start_animation(
         self,
@@ -1312,7 +1877,7 @@ class IOSViewHandler(ViewHandler):
         try:
             view.layer.removeAllAnimations()
         except Exception:
-            pass
+            diagnostics.swallowed("ios.IOSViewHandler.cancel_animation")
         return value
 
 
@@ -1322,17 +1887,18 @@ class IOSViewHandler(ViewHandler):
 
 
 class FlexContainerHandler(IOSViewHandler):
-    """Container for flex layout, a bare `UIView`.
+    """Container for flex layout, a hit-test-aware ``UIView`` subclass.
 
     All flex semantics (direction, alignment, distribution, padding)
     are computed by the layout engine and applied via
     [`set_frame`][pythonnative.native_views.ios.IOSViewHandler.set_frame].
+    The view is a ``_PNInteractiveViewCTypes`` instance so
+    ``pointer_events`` and ``hit_slop`` can be applied on any render
+    without recreating the view (see the interaction-props section).
     """
 
     def _build(self, props: Dict[str, Any]) -> Any:
-        v = ObjCClass("UIView").alloc().init()
-        v.setTranslatesAutoresizingMaskIntoConstraints_(True)
-        return v
+        return _new_container_view()
 
 
 # ======================================================================
@@ -1400,7 +1966,7 @@ class TextHandler(IOSViewHandler):
                 if desc is not None:
                     font = UIFont.fontWithDescriptor_size_(desc, size)
             except Exception:
-                pass
+                diagnostics.swallowed("ios.TextHandler._font_for")
         return font
 
     _SPAN_REBUILD_KEYS = (
@@ -1463,7 +2029,7 @@ class TextHandler(IOSViewHandler):
             try:
                 label.setAlpha_(float(props["opacity"]))
             except Exception:
-                pass
+                diagnostics.swallowed("ios.TextHandler._apply")
 
     def _apply_spans(self, label: Any, merged: Dict[str, Any]) -> None:
         """Render a rich-text span list as one NSAttributedString.
@@ -1525,13 +2091,13 @@ class TextHandler(IOSViewHandler):
                     elif span.get("text_decoration") == "line_through":
                         attr.addAttribute_value_range_("NSStrikethrough", 1, rng)
                 except Exception:
-                    pass
+                    diagnostics.swallowed("ios.TextHandler._apply_spans")
             label.setAttributedText_(attr)
         except Exception:
             try:
                 label.setText_(str(merged.get("text") or ""))
             except Exception:
-                pass
+                diagnostics.swallowed("ios.TextHandler._apply_spans")
 
     def _apply_attributed(self, label: Any, props: Dict[str, Any]) -> None:
         """Re-render the label's text as an NSAttributedString.
@@ -1576,7 +2142,7 @@ class TextHandler(IOSViewHandler):
                 attr.addAttribute_value_range_("NSStrikethrough", 1, full_range)
             label.setAttributedText_(attr)
         except Exception:
-            pass
+            diagnostics.swallowed("ios.TextHandler._apply_attributed")
 
 
 class ButtonHandler(IOSViewHandler):
@@ -1632,7 +2198,7 @@ class ButtonHandler(IOSViewHandler):
             try:
                 btn.setAlpha_(float(props["opacity"]))
             except Exception:
-                pass
+                diagnostics.swallowed("ios.ButtonHandler._apply")
 
 
 # ``scrollViewDidScroll:`` hands the delegate a ``UIScrollView*``. rubicon's
@@ -1718,24 +2284,24 @@ class ScrollViewHandler(IOSViewHandler):
                 sv.setShowsVerticalScrollIndicator_(visible)
                 sv.setShowsHorizontalScrollIndicator_(visible)
             except Exception:
-                pass
+                diagnostics.swallowed("ios.ScrollViewHandler._apply")
         if "paging_enabled" in props:
             try:
                 sv.setPagingEnabled_(bool(props["paging_enabled"]))
             except Exception:
-                pass
+                diagnostics.swallowed("ios.ScrollViewHandler._apply")
         if "bounces" in props:
             b = props["bounces"]
             try:
                 sv.setBounces_(True if b is None else bool(b))
             except Exception:
-                pass
+                diagnostics.swallowed("ios.ScrollViewHandler._apply")
         if "keyboard_dismiss_mode" in props and props["keyboard_dismiss_mode"] is not None:
             mapping = {"none": 0, "on_drag": 1, "interactive": 2}
             try:
                 sv.setKeyboardDismissMode_(mapping.get(props["keyboard_dismiss_mode"], 0))
             except Exception:
-                pass
+                diagnostics.swallowed("ios.ScrollViewHandler._apply")
 
     def command(self, native_view: Any, name: str, args: Dict[str, Any]) -> Any:
         if name == "scroll_to_offset":
@@ -1745,7 +2311,7 @@ class ScrollViewHandler(IOSViewHandler):
             try:
                 native_view.setContentOffset_animated_((x, y), animated)
             except Exception:
-                pass
+                diagnostics.swallowed("ios.ScrollViewHandler.command")
             return None
         if name == "scroll_to_end":
             animated = args.get("animated", True) is not False
@@ -1760,7 +2326,7 @@ class ScrollViewHandler(IOSViewHandler):
                 offset = (target_x, 0.0) if horizontal else (0.0, target_y)
                 native_view.setContentOffset_animated_(offset, animated)
             except Exception:
-                pass
+                diagnostics.swallowed("ios.ScrollViewHandler.command")
             return None
         if name == "get_scroll_offset":
             try:
@@ -1796,10 +2362,11 @@ class ScrollViewHandler(IOSViewHandler):
                 if existing is not None:
                     existing.endRefreshing()
                     _pn_action_handlers.pop(_recognizer_ptr(existing), None)
+                    _pn_last_control_event_ts.pop(_recognizer_ptr(existing), None)
                     sv.setRefreshControl_(None)
                     sv.setAlwaysBounceVertical_(False)
             except Exception:
-                pass
+                diagnostics.swallowed("ios.ScrollViewHandler._apply_refresh")
             return
         try:
             existing = sv.refreshControl
@@ -1816,7 +2383,7 @@ class ScrollViewHandler(IOSViewHandler):
                 try:
                     sv.setAlwaysBounceVertical_(True)
                 except Exception:
-                    pass
+                    diagnostics.swallowed("ios.ScrollViewHandler._apply_refresh")
                 existing = rc
             refreshing = bool(spec.get("refreshing")) if isinstance(spec, dict) else False
             if refreshing:
@@ -1824,7 +2391,7 @@ class ScrollViewHandler(IOSViewHandler):
             else:
                 existing.endRefreshing()
         except Exception:
-            pass
+            diagnostics.swallowed("ios.ScrollViewHandler._apply_refresh")
 
 
 class ImageHandler(IOSViewHandler):
@@ -1842,12 +2409,12 @@ class ImageHandler(IOSViewHandler):
             try:
                 iv.setTintColor_(_uicolor(props["tint_color"]))
             except Exception:
-                pass
+                diagnostics.swallowed("ios.ImageHandler._apply")
         if "placeholder_color" in props and props["placeholder_color"] is not None:
             try:
                 iv.setBackgroundColor_(_uicolor(props["placeholder_color"]))
             except Exception:
-                pass
+                diagnostics.swallowed("ios.ImageHandler._apply")
         if "source" in props and props["source"]:
             self._load_source(iv, str(props["source"]))
         if "scale_type" in props and props["scale_type"]:
@@ -1873,7 +2440,7 @@ class ImageHandler(IOSViewHandler):
                     w, h = max_width, h * scale
                 return (w, h)
         except Exception:
-            pass
+            diagnostics.swallowed("ios.ImageHandler.measure_intrinsic")
         return (0.0, 0.0)
 
     def _load_source(self, iv: Any, source: str) -> None:
@@ -1894,7 +2461,7 @@ class ImageHandler(IOSViewHandler):
                 else:
                     _fire(iv, "on_error", f"image {source!r} not found")
         except Exception:
-            pass
+            diagnostics.swallowed("ios.ImageHandler._load_source")
 
     def _load_data_uri(self, iv: Any, source: str) -> None:
         """Decode an inline ``data:`` URI (base64 payload) into the view."""
@@ -1942,7 +2509,7 @@ class ImageHandler(IOSViewHandler):
                     iv.setImage_(image)
                     _fire(iv, "on_load")
                 except Exception:
-                    pass
+                    diagnostics.swallowed("ios.ImageHandler._load_async.on_ready")
 
             def on_error(message: str) -> None:
                 if _state_of(iv).get("pending_uri") == source:
@@ -1950,7 +2517,7 @@ class ImageHandler(IOSViewHandler):
 
             fetch(source, on_ready, on_error)
         except Exception:
-            pass
+            diagnostics.swallowed("ios.ImageHandler._load_async")
 
     def _decode_downsampled(self, iv: Any, path: str) -> Any:
         """Decode a file, scaling down to the view's bounds if oversized.
@@ -2052,7 +2619,7 @@ def _tf_on_change_imp(self_ptr: int, _cmd: int, sender_ptr: int) -> None:
         try:
             view.setText_(text)
         except Exception:
-            pass
+            diagnostics.swallowed("ios._tf_on_change_imp")
         finally:
             state["suppress"] = False
     _fire(view, "on_change", text)
@@ -2077,7 +2644,7 @@ def _tf_should_return_imp(self_ptr: int, _cmd: int, tf_ptr: int) -> bool:
         _objc_msgSend.argtypes = [_ct.c_void_p, _ct.c_void_p]
         _objc_msgSend(_ct.c_void_p(int(tf_ptr or 0)), _SEL_RESIGN_FIRST_RESPONDER)
     except Exception:
-        pass
+        diagnostics.swallowed("ios._tf_should_return_imp")
     return True
 
 
@@ -2244,7 +2811,7 @@ class TextInputHandler(IOSViewHandler):
                 )
                 view.setAttributedPlaceholder_(attr)
             except Exception:
-                pass
+                diagnostics.swallowed("ios.TextInputHandler._apply")
         if "font_size" in props and props["font_size"] is not None:
             view.setFont_(UIFont.systemFontOfSize_(float(props["font_size"])))
         if "color" in props and props["color"] is not None:
@@ -2255,7 +2822,7 @@ class TextInputHandler(IOSViewHandler):
             try:
                 view.setSecureTextEntry_(bool(props["secure"]))
             except Exception:
-                pass
+                diagnostics.swallowed("ios.TextInputHandler._apply")
         if "keyboard_type" in props and props["keyboard_type"] is not None:
             mapping = {
                 "default": 0,
@@ -2270,19 +2837,19 @@ class TextInputHandler(IOSViewHandler):
             try:
                 view.setKeyboardType_(mapping.get(props["keyboard_type"], 0))
             except Exception:
-                pass
+                diagnostics.swallowed("ios.TextInputHandler._apply")
         if "auto_capitalize" in props and props["auto_capitalize"] is not None:
             # UITextAutocapitalizationType: none=0, words=1, sentences=2, all=3.
             mapping = {"none": 0, "words": 1, "sentences": 2, "characters": 3}
             try:
                 view.setAutocapitalizationType_(mapping.get(props["auto_capitalize"], 2))
             except Exception:
-                pass
+                diagnostics.swallowed("ios.TextInputHandler._apply")
         if "auto_correct" in props:
             try:
                 view.setAutocorrectionType_(1 if props["auto_correct"] else 0)
             except Exception:
-                pass
+                diagnostics.swallowed("ios.TextInputHandler._apply")
         if "return_key_type" in props and props["return_key_type"] is not None:
             mapping = {
                 "default": 0,
@@ -2299,23 +2866,23 @@ class TextInputHandler(IOSViewHandler):
             try:
                 view.setReturnKeyType_(mapping.get(props["return_key_type"], 0))
             except Exception:
-                pass
+                diagnostics.swallowed("ios.TextInputHandler._apply")
         if "selection_color" in props and props["selection_color"] is not None:
             try:
                 view.setTintColor_(_uicolor(props["selection_color"]))
             except Exception:
-                pass
+                diagnostics.swallowed("ios.TextInputHandler._apply")
         if "text_content_type" in props:
             tct = props["text_content_type"]
             try:
                 view.setTextContentType_(_ui_text_content_type(str(tct)) if tct is not None else None)
             except Exception:
-                pass
+                diagnostics.swallowed("ios.TextInputHandler._apply")
         if "clear_button" in props and is_field:
             try:
                 view.setClearButtonMode_(1 if props["clear_button"] else 0)  # 1 = WhileEditing
             except Exception:
-                pass
+                diagnostics.swallowed("ios.TextInputHandler._apply")
         # ``editable`` is present only when False (read-only). A removed
         # prop arrives as None on update, which means "editable again".
         if "editable" in props:
@@ -2327,12 +2894,12 @@ class TextInputHandler(IOSViewHandler):
                 else:
                     view.setEditable_(resolved)
             except Exception:
-                pass
+                diagnostics.swallowed("ios.TextInputHandler._apply")
         if "auto_focus" in props and props["auto_focus"]:
             try:
                 view.becomeFirstResponder()
             except Exception:
-                pass
+                diagnostics.swallowed("ios.TextInputHandler._apply")
         _apply_view_border(view, props)
         _apply_shadow(view, props)
         _apply_transform(view, props)
@@ -2341,7 +2908,7 @@ class TextInputHandler(IOSViewHandler):
             try:
                 view.setAlpha_(float(props["opacity"]))
             except Exception:
-                pass
+                diagnostics.swallowed("ios.TextInputHandler._apply")
 
     def measure_intrinsic(
         self,
@@ -2357,13 +2924,13 @@ class TextInputHandler(IOSViewHandler):
             try:
                 native_view.becomeFirstResponder()
             except Exception:
-                pass
+                diagnostics.swallowed("ios.TextInputHandler.command")
             return None
         if name == "blur":
             try:
                 native_view.resignFirstResponder()
             except Exception:
-                pass
+                diagnostics.swallowed("ios.TextInputHandler.command")
             return None
         if name == "clear":
             state = _state_of(native_view)
@@ -2481,7 +3048,7 @@ class ActivityIndicatorHandler(IOSViewHandler):
             try:
                 ai.setActivityIndicatorViewStyle_(style)
             except Exception:
-                pass
+                diagnostics.swallowed("ios.ActivityIndicatorHandler._apply")
         if "color" in props and props["color"] is not None:
             ai.setColor_(_uicolor(props["color"]))
         animating = props.get("animating")
@@ -2518,8 +3085,7 @@ class PressableHandler(IOSViewHandler):
     """
 
     def _build(self, props: Dict[str, Any]) -> Any:
-        v = ObjCClass("UIView").alloc().init()
-        v.setTranslatesAutoresizingMaskIntoConstraints_(True)
+        v = _new_container_view()
         v.setUserInteractionEnabled_(True)
         self._wire_press(v)
         return v
@@ -2563,7 +3129,7 @@ class PressableHandler(IOSViewHandler):
             try:
                 rec.setCancelsTouchesInView_(False)
             except Exception:
-                pass
+                diagnostics.swallowed("ios.PressableHandler._wire_press")
             _set_recognizer_delegate(rec)
             view.addGestureRecognizer_(rec)
             rec.retain()
@@ -2643,7 +3209,7 @@ def _press_feedback(view: Any, pressed: bool) -> None:
         UIView = ObjCClass("UIView")
         UIView.animateWithDuration_animations_(duration, lambda: view.setAlpha_(opacity))
     except Exception:
-        pass
+        diagnostics.swallowed("ios._press_feedback")
 
 
 # ======================================================================
@@ -2668,7 +3234,7 @@ class ProgressBarHandler(IOSViewHandler):
             try:
                 ai.startAnimating()
             except Exception:
-                pass
+                diagnostics.swallowed("ios.ProgressBarHandler._build")
             return ai
         pv = ObjCClass("UIProgressView").alloc().init()
         pv.setTranslatesAutoresizingMaskIntoConstraints_(True)
@@ -2684,27 +3250,27 @@ class ProgressBarHandler(IOSViewHandler):
                 try:
                     view.setColor_(_uicolor(props["color"]))
                 except Exception:
-                    pass
+                    diagnostics.swallowed("ios.ProgressBarHandler._apply")
             try:
                 view.startAnimating()
             except Exception:
-                pass
+                diagnostics.swallowed("ios.ProgressBarHandler._apply")
         else:
             if "value" in props and props["value"] is not None:
                 try:
                     view.setProgress_(float(props["value"]))
                 except Exception:
-                    pass
+                    diagnostics.swallowed("ios.ProgressBarHandler._apply")
             if "color" in props and props["color"] is not None:
                 try:
                     view.setProgressTintColor_(_uicolor(props["color"]))
                 except Exception:
-                    pass
+                    diagnostics.swallowed("ios.ProgressBarHandler._apply")
             if "track_color" in props and props["track_color"] is not None:
                 try:
                     view.setTrackTintColor_(_uicolor(props["track_color"]))
                 except Exception:
-                    pass
+                    diagnostics.swallowed("ios.ProgressBarHandler._apply")
         _apply_accessibility(view, props)
 
     def measure_intrinsic(
@@ -2771,7 +3337,7 @@ def _webview_did_finish_imp(self_ptr: int, _cmd_ptr: int, _webview_ptr: int, _na
         try:
             wv.evaluateJavaScript_completionHandler_(str(js), None)
         except Exception:
-            pass
+            diagnostics.swallowed("ios._webview_did_finish_imp")
     _fire(wv, "on_load", _webview_url(wv))
 
 
@@ -2855,7 +3421,7 @@ class WebViewHandler(IOSViewHandler):
                 try:
                     cls.declare_property(prop)
                 except Exception:
-                    pass
+                    diagnostics.swallowed("ios.WebViewHandler._build")
             _pn_wkwebview_declared = True
         config = WKWebViewConfiguration.alloc().init()
         delegate_ptr = _new_webview_delegate_ptr()
@@ -2867,14 +3433,14 @@ class WebViewHandler(IOSViewHandler):
             try:
                 config.userContentController.addScriptMessageHandler_name_(delegate, "pythonnative")
             except Exception:
-                pass
+                diagnostics.swallowed("ios.WebViewHandler._build")
         wv = WKWebView.alloc().initWithFrame_configuration_(((0, 0), (0, 0)), config)
         wv.setTranslatesAutoresizingMaskIntoConstraints_(True)
         if delegate is not None:
             try:
                 wv.setNavigationDelegate_(delegate)
             except Exception:
-                pass
+                diagnostics.swallowed("ios.WebViewHandler._build")
         if delegate_ptr:
             _pn_webview_state[delegate_ptr] = {"view": wv, "inject_js": None}
             self._delegate_ids[_objc_ptr(wv) or 0] = delegate_ptr
@@ -2907,7 +3473,7 @@ class WebViewHandler(IOSViewHandler):
             try:
                 wv.loadHTMLString_baseURL_(str(props["html"]), None)
             except Exception:
-                pass
+                diagnostics.swallowed("ios.WebViewHandler._apply")
         elif "url" in props and props["url"]:
             try:
                 NSURL = ObjCClass("NSURL")
@@ -2915,38 +3481,38 @@ class WebViewHandler(IOSViewHandler):
                 url_obj = NSURL.URLWithString_(str(props["url"]))
                 wv.loadRequest_(NSURLRequest.requestWithURL_(url_obj))
             except Exception:
-                pass
+                diagnostics.swallowed("ios.WebViewHandler._apply")
         if "scroll_enabled" in props:
             enabled = props["scroll_enabled"]
             try:
                 wv.scrollView.setScrollEnabled_(True if enabled is None else bool(enabled))
             except Exception:
-                pass
+                diagnostics.swallowed("ios.WebViewHandler._apply")
 
     def command(self, native_view: Any, name: str, args: Dict[str, Any]) -> Any:
         if name == "eval_js":
             try:
                 native_view.evaluateJavaScript_completionHandler_(str(args.get("source", "")), None)
             except Exception:
-                pass
+                diagnostics.swallowed("ios.WebViewHandler.command")
             return None
         if name == "reload":
             try:
                 native_view.reload()
             except Exception:
-                pass
+                diagnostics.swallowed("ios.WebViewHandler.command")
             return None
         if name == "go_back":
             try:
                 native_view.goBack()
             except Exception:
-                pass
+                diagnostics.swallowed("ios.WebViewHandler.command")
             return None
         if name == "go_forward":
             try:
                 native_view.goForward()
             except Exception:
-                pass
+                diagnostics.swallowed("ios.WebViewHandler.command")
             return None
         return None
 
@@ -2976,9 +3542,7 @@ class SafeAreaViewHandler(IOSViewHandler):
     """Plain container; safe-area insets are applied by the layout engine."""
 
     def _build(self, props: Dict[str, Any]) -> Any:
-        v = ObjCClass("UIView").alloc().init()
-        v.setTranslatesAutoresizingMaskIntoConstraints_(True)
-        return v
+        return _new_container_view()
 
 
 # ======================================================================
@@ -3026,13 +3590,13 @@ class ModalHandler(IOSViewHandler):
             try:
                 child.setTranslatesAutoresizingMaskIntoConstraints_(True)
             except Exception:
-                pass
+                diagnostics.swallowed("ios.ModalHandler.insert_child")
             try:
                 content = modal["content_view"]
                 count = len(list(content.subviews or []))
                 content.insertSubview_atIndex_(child, max(0, min(index, count)))
             except Exception:
-                pass
+                diagnostics.swallowed("ios.ModalHandler.insert_child")
         else:
             buf = state.setdefault("pending_children", [])
             buf.insert(max(0, min(index, len(buf))), child)
@@ -3041,7 +3605,7 @@ class ModalHandler(IOSViewHandler):
         try:
             child.removeFromSuperview()
         except Exception:
-            pass
+            diagnostics.swallowed("ios.ModalHandler.remove_child")
         buf = _state_of(parent).get("pending_children")
         if buf and child in buf:
             buf.remove(child)
@@ -3082,7 +3646,7 @@ class ModalHandler(IOSViewHandler):
                 content.setFrame_(((0, 0), (bounds.size.width, bounds.size.height)))
                 content.setAutoresizingMask_(2 | 16)  # FlexibleWidth | FlexibleHeight
             except Exception:
-                pass
+                diagnostics.swallowed("ios.ModalHandler._present")
 
             # UIModalPresentationStyle: fullScreen=0, pageSheet=1,
             # formSheet=2, overCurrentContext=6 (the dimmed overlay).
@@ -3091,7 +3655,7 @@ class ModalHandler(IOSViewHandler):
             try:
                 controller.setModalPresentationStyle_(style_int)
             except Exception:
-                pass
+                diagnostics.swallowed("ios.ModalHandler._present")
             # For sheet styles, ``dismiss_on_backdrop=False`` locks
             # interactive (swipe / outside-tap) dismissal so the modal
             # stays put until ``visible`` is driven back to False.
@@ -3099,7 +3663,7 @@ class ModalHandler(IOSViewHandler):
                 try:
                     controller.setModalInPresentation_(True)
                 except Exception:
-                    pass
+                    diagnostics.swallowed("ios.ModalHandler._present")
 
             def _on_present_complete() -> None:
                 _fire(placeholder, "on_show")
@@ -3115,7 +3679,7 @@ class ModalHandler(IOSViewHandler):
                     child.setTranslatesAutoresizingMaskIntoConstraints_(True)
                     content.addSubview_(child)
                 except Exception:
-                    pass
+                    diagnostics.swallowed("ios.ModalHandler._present")
 
             top = _top_view_controller_for_alert(UIApplication.sharedApplication)
             if top is not None:
@@ -3133,7 +3697,7 @@ class ModalHandler(IOSViewHandler):
             try:
                 controller.dismissViewControllerAnimated_completion_(True, None)
             except Exception:
-                pass
+                diagnostics.swallowed("ios.ModalHandler._dismiss")
         _fire(placeholder, "on_dismiss")
 
 
@@ -3152,10 +3716,6 @@ class ModalHandler(IOSViewHandler):
 # other delegate classes in this module.
 
 
-class _PNCGPoint(_ct.Structure):
-    _fields_ = [("x", _ct.c_double), ("y", _ct.c_double)]
-
-
 _PORTAL_POINT_INSIDE_TYPE = _ct.CFUNCTYPE(_ct.c_bool, _ct.c_void_p, _ct.c_void_p, _PNCGPoint, _ct.c_void_p)
 
 
@@ -3193,7 +3753,6 @@ def _portal_point_inside_imp(self_ptr: int, _cmd_ptr: int, point: Any, _event_pt
 
 _portal_point_inside_imp_ref = _PORTAL_POINT_INSIDE_TYPE(_portal_point_inside_imp)
 
-_UIVIEW_CLS = _get_cls(b"UIView")
 _PN_PORTAL_VIEW_CLS = _alloc_cls(_UIVIEW_CLS, b"_PNPortalViewCTypes", 0) if _UIVIEW_CLS else None
 if _PN_PORTAL_VIEW_CLS:
     _add_method(
@@ -3270,7 +3829,7 @@ class PortalHandler(IOSViewHandler):
             host.addSubview_(overlay)
             self._sync_overlay_frame(overlay, host)
         except Exception:
-            pass
+            diagnostics.swallowed("ios.PortalHandler._ensure_attached")
 
     @staticmethod
     def _sync_overlay_frame(overlay: Any, host: Any) -> None:
@@ -3286,7 +3845,7 @@ class PortalHandler(IOSViewHandler):
             overlay.setFrame_(((left, top), (w, h)))
             overlay.setAutoresizingMask_(2 | 16)  # FlexibleWidth | FlexibleHeight
         except Exception:
-            pass
+            diagnostics.swallowed("ios.PortalHandler._sync_overlay_frame")
 
     def insert_child(self, parent: Any, child: Any, index: int) -> None:
         self._ensure_attached(parent)
@@ -3313,7 +3872,7 @@ class PortalHandler(IOSViewHandler):
         try:
             overlay.release()
         except Exception:
-            pass
+            diagnostics.swallowed("ios.PortalHandler._teardown")
 
 
 # ======================================================================
@@ -3347,7 +3906,7 @@ class StatusBarHandler(IOSViewHandler):
                 mapping = {"default": 3, "light": 1, "dark": 3}
                 app.setStatusBarStyle_animated_(mapping.get(props["bar_style"], 0), True)
         except Exception:
-            pass
+            diagnostics.swallowed("ios.StatusBarHandler._apply")
 
     def set_frame(self, native_view: Any, x: float, y: float, width: float, height: float) -> None:
         return
@@ -3413,7 +3972,7 @@ def _ensure_keyboard_observer() -> None:
             None,
         )
     except Exception:
-        pass
+        diagnostics.swallowed("ios._ensure_keyboard_observer")
 
 
 class KeyboardAvoidingViewHandler(IOSViewHandler):
@@ -3429,9 +3988,7 @@ class KeyboardAvoidingViewHandler(IOSViewHandler):
 
     def _build(self, props: Dict[str, Any]) -> Any:
         _ensure_keyboard_observer()
-        v = ObjCClass("UIView").alloc().init()
-        v.setTranslatesAutoresizingMaskIntoConstraints_(True)
-        return v
+        return _new_container_view()
 
 
 # ======================================================================
@@ -3457,7 +4014,7 @@ def _tabbar_did_select_imp(self_ptr: int, cmd_ptr: int, tabbar_ptr: int, item_pt
         if 0 <= index < len(items):
             _fire_ptr(int(tabbar_ptr), "on_tab_select", items[index].get("name", ""))
     except Exception:
-        pass
+        diagnostics.swallowed("ios._tabbar_did_select_imp")
 
 
 _tabbar_imp_ref = _DELEGATE_IMP_TYPE(_tabbar_did_select_imp)
@@ -3543,7 +4100,7 @@ class TabBarHandler(IOSViewHandler):
         try:
             tab_bar.setItems_animated_(bar_items, False)
         except Exception:
-            pass
+            diagnostics.swallowed("ios.TabBarHandler._set_bar_items")
 
     def _resolve_icon(self, UIImage: Any, icon: Any) -> Any:
         """Resolve a tab icon spec to a UIImage, or return None.
@@ -3577,7 +4134,7 @@ class TabBarHandler(IOSViewHandler):
                     if i < len(all_items):
                         tab_bar.setSelectedItem_(all_items[i])
                 except Exception:
-                    pass
+                    diagnostics.swallowed("ios.TabBarHandler._set_active")
                 break
 
 
@@ -3600,7 +4157,7 @@ def _top_view_controller_for_alert(app: Any) -> Any:
     try:
         window = app.keyWindow
     except Exception:
-        pass
+        diagnostics.swallowed("ios._top_view_controller_for_alert")
 
     if window is None:
         try:
@@ -3612,7 +4169,7 @@ def _top_view_controller_for_alert(app: Any) -> Any:
             if window is None and windows:
                 window = windows[0]
         except Exception:
-            pass
+            diagnostics.swallowed("ios._top_view_controller_for_alert")
 
     if window is None:
         return None
@@ -3629,7 +4186,7 @@ def _top_view_controller_for_alert(app: Any) -> Any:
         if visible is not None:
             top = visible
     except Exception:
-        pass
+        diagnostics.swallowed("ios._top_view_controller_for_alert")
 
     while top is not None:
         try:
@@ -3677,7 +4234,7 @@ def _present_alert(
         try:
             on_result(index)
         except Exception:
-            pass
+            diagnostics.swallowed("ios._present_alert._deliver")
 
     def _present_on_main() -> None:
         try:
@@ -3778,7 +4335,7 @@ class PickerHandler(IOSViewHandler):
         try:
             btn.setTitle_forState_(_picker_button_title(merged), 0)
         except Exception:
-            pass
+            diagnostics.swallowed("ios.PickerHandler._apply")
         _apply_accessibility(btn, props)
 
     def measure_intrinsic(self, native_view: Any, max_width: float, max_height: float) -> Tuple[float, float]:
@@ -3814,10 +4371,10 @@ def _checkbox_set_image(btn: Any) -> None:
                 if tinted is not None:
                     image = tinted
             except Exception:
-                pass
+                diagnostics.swallowed("ios._checkbox_set_image")
         btn.setImage_forState_(image, 0)
     except Exception:
-        pass
+        diagnostics.swallowed("ios._checkbox_set_image")
 
 
 def _checkbox_toggle(btn: Any) -> None:
@@ -3855,7 +4412,7 @@ class CheckboxHandler(IOSViewHandler):
                 btn.setTitleColor_forState_(_uicolor("#111111"), 0)
                 btn.setTintColor_(_uicolor("#111111"))
             except Exception:
-                pass
+                diagnostics.swallowed("ios.CheckboxHandler._apply")
         if "value" in props:
             state["value"] = bool(props["value"])
         if "label" in props:
@@ -3863,14 +4420,14 @@ class CheckboxHandler(IOSViewHandler):
             try:
                 btn.setTitle_forState_(str(label) if label is not None else "", 0)
             except Exception:
-                pass
+                diagnostics.swallowed("ios.CheckboxHandler._apply")
             # An image-bearing custom button is not exposed to the
             # accessibility tree by title alone; mirror the label
             # explicitly (an accessibility_label prop still wins below).
             try:
                 btn.setAccessibilityLabel_(str(label) if label is not None else "")
             except Exception:
-                pass
+                diagnostics.swallowed("ios.CheckboxHandler._apply")
         if "disabled" in props:
             # ``disabled`` is present only when True; a removed prop
             # (None) re-enables the control.
@@ -3878,7 +4435,7 @@ class CheckboxHandler(IOSViewHandler):
             try:
                 btn.setEnabled_(not disabled)
             except Exception:
-                pass
+                diagnostics.swallowed("ios.CheckboxHandler._apply")
         _checkbox_set_image(btn)
         _apply_accessibility(btn, props)
 
@@ -3935,7 +4492,7 @@ class SegmentedControlHandler(IOSViewHandler):
                     for i, title in enumerate(new_segments):
                         control.insertSegmentWithTitle_atIndex_animated_(title, i, False)
                 except Exception:
-                    pass
+                    diagnostics.swallowed("ios.SegmentedControlHandler._apply")
                 finally:
                     state["suppress"] = False
                 rebuilt = True
@@ -3948,7 +4505,7 @@ class SegmentedControlHandler(IOSViewHandler):
             try:
                 control.setSelectedSegmentIndex_(int(merged.get("selected_index", 0) or 0))
             except Exception:
-                pass
+                diagnostics.swallowed("ios.SegmentedControlHandler._apply")
             finally:
                 state["suppress"] = False
         if "tint_color" in props and props["tint_color"] is not None:
@@ -3956,11 +4513,11 @@ class SegmentedControlHandler(IOSViewHandler):
             try:
                 control.setSelectedSegmentTintColor_(color)  # iOS 13+
             except Exception:
-                pass
+                diagnostics.swallowed("ios.SegmentedControlHandler._apply")
             try:
                 control.setTintColor_(color)
             except Exception:
-                pass
+                diagnostics.swallowed("ios.SegmentedControlHandler._apply")
         if "enabled" in props:
             # ``enabled`` is present only when False; a removed prop
             # (None) re-enables the control.
@@ -3968,7 +4525,7 @@ class SegmentedControlHandler(IOSViewHandler):
             try:
                 control.setEnabled_(True if enabled is None else bool(enabled))
             except Exception:
-                pass
+                diagnostics.swallowed("ios.SegmentedControlHandler._apply")
         _apply_accessibility(control, props)
 
     def measure_intrinsic(self, native_view: Any, max_width: float, max_height: float) -> Tuple[float, float]:
@@ -4007,7 +4564,7 @@ def _date_formatter(mode: str) -> Any:
         NSLocale = ObjCClass("NSLocale")
         formatter.setLocale_(NSLocale.alloc().initWithLocaleIdentifier_("en_US_POSIX"))
     except Exception:
-        pass
+        diagnostics.swallowed("ios._date_formatter")
     formatter.retain()
     _pn_date_formatters[fmt] = formatter
     return formatter
@@ -4024,7 +4581,7 @@ class DatePickerHandler(IOSViewHandler):
         try:
             picker.setPreferredDatePickerStyle_(2)  # UIDatePickerStyleCompact
         except Exception:
-            pass
+            diagnostics.swallowed("ios.DatePickerHandler._build")
 
         def _on_change() -> None:
             state = _state_of(picker)
@@ -4049,7 +4606,7 @@ class DatePickerHandler(IOSViewHandler):
             try:
                 picker.setDatePickerMode_(mode_map.get(mode, 1))
             except Exception:
-                pass
+                diagnostics.swallowed("ios.DatePickerHandler._apply")
         if "minimum" in props:
             self._set_bound(picker, "setMinimumDate_", props["minimum"], mode)
         if "maximum" in props:
@@ -4064,7 +4621,7 @@ class DatePickerHandler(IOSViewHandler):
                 try:
                     picker.setDate_animated_(date, False)
                 except Exception:
-                    pass
+                    diagnostics.swallowed("ios.DatePickerHandler._apply")
                 finally:
                     state["suppress"] = False
         if "enabled" in props:
@@ -4074,7 +4631,7 @@ class DatePickerHandler(IOSViewHandler):
             try:
                 picker.setEnabled_(True if enabled is None else bool(enabled))
             except Exception:
-                pass
+                diagnostics.swallowed("ios.DatePickerHandler._apply")
         _apply_accessibility(picker, props)
 
     def _set_bound(self, picker: Any, selector: str, value: Any, mode: str) -> None:
@@ -4085,7 +4642,7 @@ class DatePickerHandler(IOSViewHandler):
             date = _date_formatter(mode).dateFromString_(str(value))
             getattr(picker, selector)(date)
         except Exception:
-            pass
+            diagnostics.swallowed("ios.DatePickerHandler._set_bound")
 
     def measure_intrinsic(self, native_view: Any, max_width: float, max_height: float) -> Tuple[float, float]:
         try:
@@ -4230,7 +4787,7 @@ def _table_cell_imp(self_ptr: int, cmd_ptr: int, tv_ptr: int, ip_ptr: int) -> in
             cell.setFrame_(((0, 0), (cell_w, row_h)))
             cell.contentView.setFrame_(((0, 0), (cell_w, row_h)))
         except Exception:
-            pass
+            diagnostics.swallowed("ios._table_cell_imp")
 
         content = cell.contentView
         try:
@@ -4240,7 +4797,7 @@ def _table_cell_imp(self_ptr: int, cmd_ptr: int, tv_ptr: int, ip_ptr: int) -> in
             for sub in list(existing_subs or []):
                 sub.removeFromSuperview()
         except Exception:
-            pass
+            diagnostics.swallowed("ios._table_cell_imp")
 
         # Only rows in (or near) the visible content window get a
         # mounted subtree. UITableView's accessibility container calls
@@ -4270,7 +4827,7 @@ def _table_cell_imp(self_ptr: int, cmd_ptr: int, tv_ptr: int, ip_ptr: int) -> in
         try:
             cell.setAccessibilityElementsHidden_(not in_window)
         except Exception:
-            pass
+            diagnostics.swallowed("ios._table_cell_imp")
 
         if in_window and info is not None:
             render_row = info.get("render_row")
@@ -4289,7 +4846,7 @@ def _table_cell_imp(self_ptr: int, cmd_ptr: int, tv_ptr: int, ip_ptr: int) -> in
                         try:
                             root.setFrame_(((0, 0), (cell_w, row_h)))
                         except Exception:
-                            pass
+                            diagnostics.swallowed("ios._table_cell_imp")
                 except Exception:
                     print(f"[VirtualList][iOS] mount for row={row} raised:")
                     _tb.print_exc()
@@ -4314,7 +4871,7 @@ def _table_did_select_imp(self_ptr: int, cmd_ptr: int, tv_ptr: int, ip_ptr: int)
         _objc_msgSend.argtypes = [_ct.c_void_p, _ct.c_void_p, _ct.c_void_p, _ct.c_bool]
         _objc_msgSend(_ct.c_void_p(tv_ptr), _SEL_DESELECT_ROW, _ct.c_void_p(ip_ptr), True)
     except Exception:
-        pass
+        diagnostics.swallowed("ios._table_did_select_imp")
     _fire_ptr(int(tv_ptr or 0), "on_row_press", row)
 
 
@@ -4440,7 +4997,7 @@ class VirtualListHandler(IOSViewHandler):
                 estimate = float(props.get("row_height", 44.0) or 44.0)
             tv.setEstimatedRowHeight_(max(1.0, estimate))
         except Exception:
-            pass
+            diagnostics.swallowed("ios.VirtualListHandler._build")
         tv.retain()
         _pn_retained_views.append(tv)
 
@@ -4498,12 +5055,12 @@ class VirtualListHandler(IOSViewHandler):
             try:
                 tv.setShowsVerticalScrollIndicator_(visible)
             except Exception:
-                pass
+                diagnostics.swallowed("ios.VirtualListHandler._apply")
         if data_changed and not initial:
             try:
                 tv.reloadData()
             except Exception:
-                pass
+                diagnostics.swallowed("ios.VirtualListHandler._apply")
 
     def _teardown(self, tv: Any) -> None:
         info = self._source_state(tv)
@@ -4512,7 +5069,7 @@ class VirtualListHandler(IOSViewHandler):
         try:
             info["pool"].release_all()
         except Exception:
-            pass
+            diagnostics.swallowed("ios.VirtualListHandler._teardown")
         info["tv"] = None
         _pn_table_state.pop(info.get("source_ptr"), None)
 
@@ -4536,7 +5093,7 @@ class VirtualListHandler(IOSViewHandler):
             try:
                 native_view.setContentOffset_animated_((0.0, y), animated)
             except Exception:
-                pass
+                diagnostics.swallowed("ios.VirtualListHandler.command")
             return None
         if name == "scroll_to_index":
             index = int(args.get("index", 0) or 0)
@@ -4549,7 +5106,7 @@ class VirtualListHandler(IOSViewHandler):
                 # 1 = UITableViewScrollPositionTop
                 native_view.scrollToRowAtIndexPath_atScrollPosition_animated_(path, 1, animated)
             except Exception:
-                pass
+                diagnostics.swallowed("ios.VirtualListHandler.command")
             return None
         if name == "scroll_to_end":
             animated = args.get("animated", True) is not False
@@ -4559,7 +5116,7 @@ class VirtualListHandler(IOSViewHandler):
                 target = max(0.0, content_h - bounds_h)
                 native_view.setContentOffset_animated_((0.0, target), animated)
             except Exception:
-                pass
+                diagnostics.swallowed("ios.VirtualListHandler.command")
             return None
         if name == "get_scroll_offset":
             try: