pythonnative 0.39.0__tar.gz → 0.40.0__tar.gz

pythonnative-0.40.0/MANIFEST.in

@@ -0,0 +1,11 @@
+global-exclude *.pyc *.pyo .DS_Store
+recursive-exclude src/pythonnative/native .build/* .gradle/* .cxx/* build/* .swiftpm/* .kotlin/*
+prune src/pythonnative/native/android/build
+prune src/pythonnative/native/android/.gradle
+prune src/pythonnative/native/android/.cxx
+prune src/pythonnative/native/ios/.build
+prune src/pythonnative/native/ios/.swiftpm
+prune src/pythonnative/native/yoga/.build
+prune src/pythonnative/templates/android_template/app/build
+prune src/pythonnative/templates/android_template/.gradle
+prune src/pythonnative/templates/ios_template/build

{pythonnative-0.39.0/src/pythonnative.egg-info → pythonnative-0.40.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonnative
-Version: 0.39.0
+Version: 0.40.0
 Summary: Cross-platform native UI toolkit for Android and iOS
 Author: Owen Carey
 License: MIT License

{pythonnative-0.39.0 → pythonnative-0.40.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pythonnative"
-version = "0.39.0"
+version = "0.40.0"
 description = "Cross-platform native UI toolkit for Android and iOS"
 authors = [
   { name = "Owen Carey" }
@@ -93,8 +93,15 @@ license-files = ["LICENSE*"]
 [tool.setuptools.package-data]
 pythonnative = [
   "py.typed",
-  "templates/**",
-  "devserver/static/*",
+  "templates/**", "native/**", "sdk/templates/**",
+  "devserver/static/**",
+]
+
+[tool.setuptools.exclude-package-data]
+pythonnative = [
+  "**/build/**", "**/.build/**", "**/.gradle/**",
+  "**/.cxx/**", "**/.swiftpm/**", "**/.kotlin/**",
+  "**/__pycache__/**", "**/.DS_Store",
 ]
 
 [tool.ruff]

pythonnative-0.40.0/setup.py

@@ -0,0 +1,19 @@
+"""Build the host Yoga binding; mobile hosts compile the vendored core."""
+
+import os
+from pathlib import Path
+
+from setuptools import Extension, setup
+
+root = Path("src/pythonnative/native/yoga")
+setup(
+    ext_modules=[
+        Extension(
+            "pythonnative._yoga",
+            sources=[str(root / "python.cpp"), *map(str, sorted((root / "yoga").rglob("*.cpp")))],
+            include_dirs=[str(root)],
+            language="c++",
+            extra_compile_args=["/std:c++20"] if os.name == "nt" else ["-std=c++20"],
+        )
+    ]
+)

{pythonnative-0.39.0 → pythonnative-0.40.0}/src/pythonnative/__init__.py

@@ -62,9 +62,9 @@ Example:
     ```
 """
 
-__version__ = "0.39.0"
+__version__ = "0.40.0"
 
-from . import appearance, diagnostics, gestures, images, runtime, sdk
+from . import appearance, diagnostics, gestures, runtime, sdk
 from .alerts import Alert
 from .animated import Animated, AnimatedValue, use_animated_value
 from .component import Component, component, memo
@@ -348,7 +348,6 @@ __all__ = [
     # Appearance
     "appearance",
     # Image pipeline
-    "images",
     # Animation
     "Animated",
     "AnimatedValue",

{pythonnative-0.39.0 → pythonnative-0.40.0}/src/pythonnative/animated.py

@@ -85,7 +85,7 @@ import weakref
 from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple
 
 from .element import Element
-from .hooks import use_effect, use_ref
+from .hooks import Ref, use_effect, use_ref
 from .runtime import resolve_future
 from .style import StyleProp, resolve_style
 
@@ -243,12 +243,17 @@ class AnimatedNode:
         except Exception:
             pass
 
+        from .animation_graph import install
+
+        install(self)
+
         def _detach() -> None:
             with self._lock:
                 try:
                     self._attachments.remove(binding)
                 except ValueError:
                     pass
+            install(self, detached_tag=tag)
 
         return _detach
 
@@ -404,6 +409,12 @@ class AnimatedValue(AnimatedNode):
     def set_value(self, new_value: float) -> None:
         """Set the value immediately, pushing to native views and listeners."""
         self._apply(float(new_value), push_native=True)
+        from .animation_graph import install
+
+        graph = install(self)
+        if graph and graph["bindings"]:
+            backend = _backend()
+            backend.set_animated_property(graph["bindings"][0][0], f"_pn_graph:{id(self)}", float(new_value))
 
     def _apply(self, new_value: float, push_native: bool) -> None:
         with self._lock:
@@ -695,7 +706,12 @@ class AnimatedEvent:
             if raw is None:
                 continue
             try:
-                node.set_value(float(raw))
+                if getattr(_backend(), "install_animation_graph", None) is not None:
+                    # Native already evaluated the graph at the input timestamp.
+                    # Python observes the sample without echoing an older frame.
+                    node._value = float(raw)
+                else:
+                    node.set_value(float(raw))
             except (TypeError, ValueError):
                 continue
         if self._listener is not None:
@@ -1041,21 +1057,21 @@ def _start_native(value: AnimatedValue, spec: Dict[str, Any]) -> Optional[_Nativ
     animation; otherwise rolls back any accepted targets and returns
     ``None`` so the caller falls back to the Python ticker.
     """
-    targets = value.attachments()
-    if not targets:
-        return None
-    if value.has_listeners():
-        # Python listeners want per-frame values; only the ticker
-        # provides those.
-        return None
-    if value._has_dependents():
-        # Derived nodes (interpolations, arithmetic) need per-frame
-        # Python evaluation to keep their own attachments in sync.
-        return None
     try:
         backend = _backend()
     except Exception:
         return None
+    from .animation_graph import install
+
+    graph = install(value)
+    if graph and graph["bindings"]:
+        targets = [(graph["bindings"][0][0], f"_pn_graph:{id(value)}")]
+    else:
+        targets = value.attachments()
+        if value._has_dependents():
+            return None
+    if not targets or value.has_listeners():
+        return None
 
     group = _NativeAnimationGroup(value, _projected_final_value(spec))
     accepted: List[Tuple[int, int]] = []  # (anim_id, tag)
@@ -1368,24 +1384,32 @@ def _make_animated_factory(
         plain_style, bindings = _resolve_style_with_values(style)
 
         ref = use_ref(None)
+        attached: Ref[List[Callable[[], None]]] = use_ref([])
 
-        def _attach_bindings() -> Callable[[], None]:
+        def _attach_bindings() -> None:
             tag = ref._pn_tag
             if tag is None:
-                return lambda: None
+                return
+            # Derived nodes can be rebuilt on every render. Install their new
+            # bindings before releasing the old ones so a running native graph
+            # never temporarily loses every owner.
             detachers = [value.attach(tag, _animated_prop_name(prop)) for prop, value in bindings.items()]
+            previous = attached.current
+            attached.current = detachers
+            for detach in previous:
+                detach()
 
+        def _unmount_bindings() -> Callable[[], None]:
             def _cleanup() -> None:
-                for fn in detachers:
-                    try:
-                        fn()
-                    except Exception:
-                        pass
+                for detach in attached.current:
+                    detach()
+                attached.current = []
 
             return _cleanup
 
         # Re-attach whenever the binding set changes identity.
         use_effect(_attach_bindings, [tuple(sorted((k, id(v)) for k, v in bindings.items()))])
+        use_effect(_unmount_bindings, [])
 
         if element_type == "Text":
             text = children[0] if children else kwargs.pop("text", "")

pythonnative-0.40.0/src/pythonnative/animation_graph.py

@@ -0,0 +1,78 @@
+"""Portable animation expressions evaluated by the native UI thread."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def serialize(root: Any) -> dict[str, Any]:
+    """Serialize one connected animation graph in dependency order."""
+    from .animated import AnimatedInterpolation, AnimatedNode, AnimatedValue, _AnimatedDiffClamp, _AnimatedOperation
+
+    connected: dict[int, Any] = {}
+
+    def discover(node: Any) -> None:
+        if not isinstance(node, AnimatedNode) or id(node) in connected:
+            return
+        connected[id(node)] = node
+        for child in list(node._children):
+            discover(child)
+        for parent in getattr(node, "_parents", [getattr(node, "_parent", None)]):
+            discover(parent)
+
+    discover(root)
+    encoded: dict[int, dict[str, Any]] = {}
+
+    def encode(node: Any) -> Any:
+        if not isinstance(node, AnimatedNode):
+            return {"constant": float(node)}
+        identity = id(node)
+        if identity not in encoded:
+            definition: dict[str, Any] = {"id": identity}
+            if isinstance(node, AnimatedValue):
+                definition.update(kind="value", value=node.value)
+            elif isinstance(node, AnimatedInterpolation):
+                definition.update(
+                    kind="interpolate",
+                    inputs=[encode(node._parent)],
+                    ranges=node._inputs,
+                    outputs=node._outputs,
+                    color=node._kind == "color",
+                    left=node._left,
+                    right=node._right,
+                )
+            elif isinstance(node, _AnimatedOperation):
+                definition.update(kind=node._op, inputs=[encode(parent) for parent in node._parents])
+            elif isinstance(node, _AnimatedDiffClamp):
+                definition.update(
+                    kind="diff_clamp",
+                    inputs=[encode(node._parent)],
+                    minimum=node._min,
+                    maximum=node._max,
+                    previous=node._last_input,
+                    value=node.value,
+                )
+            else:
+                raise TypeError(f"Unsupported animated node {type(node).__name__}")
+            encoded[identity] = definition
+        return {"node": identity}
+
+    for node in connected.values():
+        encode(node)
+    bindings = [[tag, prop, id(node)] for node in connected.values() for tag, prop in node.attachments()]
+    return {"id": min(connected), "nodes": list(encoded.values()), "bindings": bindings}
+
+
+def install(node: Any, *, detached_tag: int | None = None) -> dict[str, Any] | None:
+    """Synchronize native graph ownership when a binding is attached or removed."""
+    from .animated import _backend
+
+    backend = _backend()
+    handler = getattr(backend, "install_animation_graph", None)
+    if handler is None:
+        return None
+    graph = serialize(node)
+    tag = graph["bindings"][0][0] if graph["bindings"] else detached_tag
+    if tag is not None:
+        handler(tag, graph)
+    return graph

{pythonnative-0.39.0 → pythonnative-0.40.0}/src/pythonnative/bootstrap.py

@@ -37,7 +37,7 @@ def start(dev: bool = False, strict: bool = False) -> Dict[str, Any]:
             error screen with the full traceback.
 
     Returns:
-        A status dict (``{"protocol": 1, "platform": "ios"}``) that the
+        A status dict (``{"protocol": 2, "platform": "ios"}``) that the
         template logs. Unless ``strict`` is set this never raises:
         failures are printed and reported in the dict under
         ``"error"``.
@@ -57,6 +57,12 @@ def start(dev: bool = False, strict: bool = False) -> Dict[str, Any]:
                 _ios_log.install()
             except Exception:
                 pass
+        from .runtime import start as start_runtime
+
+        start_runtime()
+        from .sdk.schema import load_bundled_contracts
+
+        load_bundled_contracts()
         from . import bridge
 
         status_["protocol"] = bridge.handshake()
@@ -65,11 +71,6 @@ def start(dev: bool = False, strict: bool = False) -> Dict[str, Any]:
             from . import diagnostics
 
             diagnostics.set_dev_mode(True)
-        # Create the guest loop now so the first pump request has a
-        # loop to drive and effects can schedule work during mount.
-        from .runtime import get_loop
-
-        get_loop()
         # Import the view backend eagerly: on a slow device the first
         # commit shouldn't also pay for importing the reconciler.
         from .native_views import get_registry

{pythonnative-0.39.0 → pythonnative-0.40.0}/src/pythonnative/bridge/__init__.py

@@ -19,8 +19,7 @@ tests that want to exercise the bridge itself install a
 from __future__ import annotations
 
 import threading
-from collections import deque
-from typing import Any, Callable, Deque, Dict, Optional, Protocol, Tuple
+from typing import Callable, Optional, Protocol, Tuple
 
 from . import codec
 
@@ -31,11 +30,11 @@ __all__ = [
     "has_transport",
     "handshake",
     "native_callback",
-    "post_to_main",
     "set_transport",
 ]
 
-PROTOCOL_VERSION = 1
+from .commits import PROTOCOL_VERSION
+
 """Bridge protocol version this Python package speaks."""
 
 
@@ -47,7 +46,7 @@ class Transport(Protocol):
     def protocol_version(self) -> int:
         """Return the protocol version compiled into the native library."""
 
-    def apply(self, transaction_json: str) -> None:
+    def apply(self, transaction_json: str) -> str:
         """Apply one serialized transaction (a JSON array of ops)."""
 
     def measure(self, tag: int, max_width: float, max_height: float) -> Tuple[float, float]:
@@ -154,58 +153,29 @@ def handshake() -> int:
             f"expects v{PROTOCOL_VERSION}. Re-run 'pn build' so the staged template matches the "
             "installed pythonnative package."
         )
+    if getattr(get_transport(), "name", "") in {"ios", "android"}:
+        from ..sdk.schema import fingerprint
+
+        reply = codec.loads(get_transport().call("Runtime", "capabilities", codec.dumps({"id": 0, "args": {}})))
+        capabilities = reply.get("value", {}) if isinstance(reply, dict) else {}
+        if capabilities.get("schema") != fingerprint() or capabilities.get("yoga") != "3.2.1":
+            raise RuntimeError("Native component contracts changed. Rebuild the app with 'pn run'.")
     return version
 
 
 # ======================================================================
-# Main-queue posting
+# native -> Python
 # ======================================================================
-#
-# The asyncio guest loop and ``call_on_main_thread`` need a way to run
-# a callable on the platform main thread's next turn. Native provides
-# it: ``Host.post()`` schedules ``callback("pump")``, which drains this
-# queue. Keeping the queue in Python means one native crossing per
-# batch of callables rather than one per callable.
-
-_main_queue: Deque[Callable[[], None]] = deque()
-_main_queue_lock = threading.Lock()
-_pump_requested = False
-
-
-def post_to_main(fn: Callable[[], None]) -> None:
-    """Queue ``fn`` for the next main-thread turn (never runs inline)."""
-    global _pump_requested
-    with _main_queue_lock:
-        _main_queue.append(fn)
-        if _pump_requested:
-            return
-        _pump_requested = True
-    try:
-        get_transport().call("Host", "post", codec.dumps({"call_id": 0, "args": {}}))
-    except Exception as exc:
-        with _main_queue_lock:
-            _pump_requested = False
-        print(f"[pn.bridge] Host.post failed; running {len(_main_queue)} queued callable(s) inline: {exc!r}")
-        _drain_main_queue()
-
-
-def _drain_main_queue() -> None:
-    global _pump_requested
-    while True:
-        with _main_queue_lock:
-            if not _main_queue:
-                _pump_requested = False
-                return
-            fn = _main_queue.popleft()
-        try:
-            fn()
-        except Exception as exc:
-            print(f"[pn.bridge] main-thread callable raised: {exc!r}")
 
 
-# ======================================================================
-# native -> Python
-# ======================================================================
+# Callback threads coalesce continuous input before the application loop drains.
+_continuous: dict[tuple[int, str], list[str]] = {}
+
+
+def _deliver_continuous(tag: int, name: str, slot: list[str]) -> None:
+    if _continuous.get((tag, name)) is slot:
+        _continuous.pop((tag, name), None)
+    native_callback("event", tag, name, slot[0])
 
 
 def native_callback(kind: str, tag: int, name: str, payload: str) -> Optional[str]:
@@ -225,7 +195,31 @@ def native_callback(kind: str, tag: int, name: str, payload: str) -> Optional[st
         ``diagnostics`` so nothing propagates into UIKit or the
         Android looper.
     """
+    from ..runtime import _on_loop_thread, get_loop
+
+    loop = get_loop()
+    if loop.is_running() and not _on_loop_thread(loop):
+        if kind == "event" and name in {"on_scroll", "on_selection_change", "on_gesture_update"}:
+            key = (tag, name)
+            slot = _continuous.get(key)
+            if slot is None:
+                slot = [payload]
+                _continuous[key] = slot
+                loop.call_soon_threadsafe(_deliver_continuous, tag, name, slot)
+            else:
+                slot[0] = payload
+        else:
+            _continuous.clear()
+            loop.call_soon_threadsafe(native_callback, kind, tag, name, payload)
+        return None
     try:
+        if kind == "layout":
+            from ..native_views import get_registry
+
+            backend = get_registry()
+            if backend.on_layout is not None:
+                backend.on_layout(codec.loads(payload))
+            return None
         if kind == "event":
             return _on_event(int(tag), name, payload)
         if kind == "module":
@@ -243,9 +237,6 @@ def native_callback(kind: str, tag: int, name: str, payload: str) -> Optional[st
             data = codec.loads(payload) or {}
             native_animation_completed(int(data.get("id", 0)), bool(data.get("finished", True)))
             return None
-        if kind == "pump":
-            _drain_main_queue()
-            return None
         print(f"[pn.bridge] unknown callback kind {kind!r}")
     except Exception as exc:
         from .. import diagnostics
@@ -261,6 +252,14 @@ def _on_event(tag: int, name: str, payload: str) -> Optional[str]:
     from ..events import get_event_registry
 
     args = codec.loads(payload)
+    from ..native_views import get_registry
+
+    backend = get_registry()
+    accept = getattr(backend, "accept_event", None)
+    if accept is not None:
+        if not accept(tag, name, args):
+            return None
+        args = args["args"]
     if args is None:
         args = []
     elif not isinstance(args, list):
@@ -276,7 +275,7 @@ def _on_event(tag: int, name: str, payload: str) -> Optional[str]:
             return None if result is None else codec.dumps(codec.to_jsonable(result))
         return None
     try:
-        result = callback(*args)
+        result = get_event_registry().invoke(tag, name, *args)
     except Exception as exc:
         from .. import diagnostics
 
@@ -285,7 +284,9 @@ def _on_event(tag: int, name: str, payload: str) -> Optional[str]:
 
             traceback.print_exc()
         return None
-    if result is None:
+    import inspect
+
+    if result is None or inspect.isawaitable(result):
         return None
     try:
         return codec.dumps(codec.to_jsonable(result))
@@ -294,20 +295,8 @@ def _on_event(tag: int, name: str, payload: str) -> Optional[str]:
 
 
 def _reset_for_tests() -> None:
-    """Drop the transport and any queued main-thread work (test isolation)."""
-    global _transport, _explicit, _pump_requested
+    """Drop the transport for test isolation."""
+    global _transport, _explicit
     with _transport_lock:
         _transport = None
         _explicit = False
-    with _main_queue_lock:
-        _main_queue.clear()
-        _pump_requested = False
-
-
-def transport_state() -> Dict[str, Any]:
-    """Diagnostics snapshot (used by ``pn doctor`` and tests)."""
-    return {
-        "transport": None if _transport is None else _transport.name,
-        "protocol_version": PROTOCOL_VERSION,
-        "queued_main_callables": len(_main_queue),
-    }

{pythonnative-0.39.0 → pythonnative-0.40.0}/src/pythonnative/bridge/android.py

@@ -39,9 +39,9 @@ class AndroidTransport:
         """Return the protocol version compiled into the native library."""
         return int(self._bridge.protocolVersion())
 
-    def apply(self, transaction_json: str) -> None:
+    def apply(self, transaction_json: str) -> str:
         """Apply one serialized transaction (a JSON array of ops)."""
-        self._bridge.apply(transaction_json)
+        return str(self._bridge.apply(transaction_json))
 
     def measure(self, tag: int, max_width: float, max_height: float) -> Tuple[float, float]:
         """Return the intrinsic ``(width, height)`` of the view ``tag`` under the constraints."""

{pythonnative-0.39.0 → pythonnative-0.40.0}/src/pythonnative/bridge/codec.py

@@ -88,6 +88,12 @@ def split_props(props: Dict[str, Any]) -> Tuple[Dict[str, Any], Dict[str, Any]]:
     python: Dict[str, Any] = {}
     for key, value in props.items():
         if callable(value) and not isinstance(value, type):
+            from ..animated import AnimatedEvent
+
+            if isinstance(value, AnimatedEvent):
+                wire.setdefault("_pn_animated_events", {})[key] = {
+                    name: id(node) for name, node in value._bindings.items()
+                }
             python[key] = value
             continue
         try:

pythonnative-0.40.0/src/pythonnative/bridge/commits.py

@@ -0,0 +1,114 @@
+"""Versioned commit validation and surface ownership.
+
+A commit is validated in full before it changes a native tree. Revisions are
+strictly consecutive within an application and surface. A failed native mount
+poisons that surface until the host explicitly resets and remounts it.
+"""
+
+from __future__ import annotations
+
+import copy
+import math
+from dataclasses import dataclass, field
+from typing import Any
+
+PROTOCOL_VERSION = 2
+
+
+class CommitError(RuntimeError):
+    """A malformed, stale, or failed native transaction."""
+
+
+@dataclass
+class ViewState:
+    """Wire-visible view state used to validate a whole transaction."""
+
+    type_name: str
+    props: dict[str, Any]
+    parent: int | None = None
+    children: list[int] = field(default_factory=list)
+
+
+@dataclass
+class CommitState:
+    """Committed revision and structural state for one native surface."""
+
+    application: str = ""
+    surface: int = 0
+    revision: int = 0
+    views: dict[int, ViewState] = field(default_factory=dict)
+
+    def prepare(self, envelope: Any) -> CommitState:
+        """Validate without mutating this state and return the candidate state."""
+        if not isinstance(envelope, dict) or envelope.get("version") != PROTOCOL_VERSION:
+            raise CommitError("Expected a protocol v2 commit envelope; rebuild the native client")
+        application, surface, revision = (envelope.get(k) for k in ("application", "surface", "revision"))
+        if not isinstance(application, str) or not application or type(surface) is not int or surface <= 0:
+            raise CommitError("Invalid application or surface identity")
+        if self.application and (application, surface) != (self.application, self.surface):
+            raise CommitError("Commit belongs to another application or surface")
+        if type(revision) is not int or revision != self.revision + 1:
+            raise CommitError(f"Expected revision {self.revision + 1}, received {revision!r}")
+        ops = envelope.get("ops")
+        if not isinstance(ops, list):
+            raise CommitError("Commit ops must be a list")
+        result = CommitState(application, surface, revision, copy.deepcopy(self.views))
+        for index, op in enumerate(ops):
+            try:
+                result._validate_op(op)
+            except (KeyError, TypeError, ValueError, IndexError) as exc:
+                raise CommitError(f"Invalid op {index}: {exc}") from exc
+        return result
+
+    def _validate_op(self, op: Any) -> None:
+        if not isinstance(op, list) or len(op) < 2:
+            raise ValueError("Expected an operation array")
+        code, tag = op[:2]
+        lengths = {"c": 4, "u": 3, "i": 4, "d": 2, "f": 6}
+        if code not in lengths or len(op) != lengths[code] or type(tag) is not int or tag <= 0:
+            raise ValueError("Invalid opcode, arity, or tag")
+        if code == "c":
+            if tag in self.views or not isinstance(op[2], str) or not op[2] or not isinstance(op[3], dict):
+                raise ValueError("Invalid or duplicate create")
+            self.views[tag] = ViewState(op[2], dict(op[3]))
+            return
+        view = self.views[tag]
+        if code == "u":
+            if not isinstance(op[2], dict):
+                raise ValueError("Update requires a property mapping")
+            for name, value in op[2].items():
+                if value is None:
+                    view.props.pop(name, None)
+                else:
+                    view.props[name] = value
+        elif code == "i":
+            child_tag, index = op[2:]
+            if type(child_tag) is not int or type(index) is not int or index < 0:
+                raise ValueError("Invalid child or insertion index")
+            child = self.views[child_tag]
+            ancestor: int | None = tag
+            while ancestor is not None:
+                if ancestor == child_tag:
+                    raise ValueError("Insertion creates a cycle")
+                ancestor = self.views[ancestor].parent
+            if child.parent is not None:
+                self.views[child.parent].children.remove(child_tag)
+            if index > len(view.children):
+                raise ValueError("Insertion index exceeds child count")
+            view.children.insert(index, child_tag)
+            child.parent = tag
+        elif code == "d":
+            if view.children:
+                raise ValueError("Destroy children before their parent")
+            if view.parent is not None:
+                self.views[view.parent].children.remove(tag)
+            del self.views[tag]
+        elif code == "f":
+            if any(type(n) not in (float, int) or not math.isfinite(n) for n in op[2:]):
+                raise ValueError("Frame values must be finite numbers")
+            if op[4] < 0 or op[5] < 0:
+                raise ValueError("Frame sizes must be nonnegative")
+
+    def acknowledgement(self) -> dict[str, Any]:
+        """Identify the exact revision native successfully mounted."""
+        return {"ok": True, "application": self.application, "surface": self.surface, "revision": self.revision}