pgwidgets-python 0.2.0__tar.gz → 0.2.3__tar.gz

{pgwidgets_python-0.2.0 → pgwidgets_python-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pgwidgets-python
-Version: 0.2.0
+Version: 0.2.3
 Summary: Python bindings for the pgwidgets JavaScript widget library
 Author: PGWidgets Developers
 License: BSD-3-Clause
@@ -17,7 +17,7 @@ Classifier: Topic :: Software Development :: User Interfaces
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
-Requires-Dist: pgwidgets-js
+Requires-Dist: pgwidgets-js>=0.2.0
 Requires-Dist: websockets>=12
 Provides-Extra: dev
 Requires-Dist: sphinx; extra == "dev"

{pgwidgets_python-0.2.0 → pgwidgets_python-0.2.3}/docs/WhatsNew.rst

@@ -1,13 +1,76 @@
 What's New
 ==========
 
-Significant changes since the last tagged release (``v0.1.3``).
+Recent changes — since ``v0.2.1``
+---------------------------------
+
+Reliable ``get_size()`` / ``get_position()`` on every visual widget
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The auto-sync layer that backs widget getters has been reworked so
+``widget.get_size()`` (and ``get_position()`` where supported)
+returns the current layout-determined value for any visual widget,
+not just ones that opted into the ``resizable`` / ``moveable``
+options.  The binding now installs a *passive* resize listener on
+every visual widget — the value is captured into local state for
+the getter, but it is **not** pushed to other connected browsers or
+replayed on reconstruction.  Explicit ``widget.resize(w, h)`` calls
+are still replayed, as is interactive resize on widgets that opted
+into active sync.
+
+The user-visible upshot: code that calls ``image.get_size()`` on an
+``Image`` placed in a flex container now returns the real pixel
+size the browser laid the widget out at, instead of ``None`` or a
+stale value.  And widgets like ``Image`` with
+``set_expanding(True, True)`` no longer get pinned to pixel
+dimensions on reconnect (a regression in earlier auto-sync work).
+
+The same guard now applies in both reconstruction paths
+(top-level state replay AND ``_transfer_proxy`` for factory-created
+widgets like ``ToolBarAction``), which fixes a "toolbar items
+drift farther apart after each reconnect" bug.
+
+``map`` callback survives reconstruction
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The Python side now forwards ``map`` callbacks during a reconstruct
+window instead of suppressing them along with the rest of the
+state-replay echoes.  ``map`` is a one-shot lifecycle event tied to
+the widget first becoming visually present; missing it on the
+Python side meant a user's map handler stayed un-fired until the
+window happened to be resized.  Pairs with the JS-side reliability
+work for the same callback.
+
+Sensible defaults for more getters
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Getters now return useful zero-value defaults before any state has
+been set or reported from the browser, instead of ``None``:
+
+- ``get_scroll_position()`` → ``(0.0, 0.0)``
+- ``get_scroll_percent()`` → ``(0.0, 0.0)`` (or ``0.0`` on
+  ``ScrollBar``, which uses a single-axis API)
+- ``get_thumb_percent()`` → ``(0.0, 0.0)`` (or ``0.0`` on
+  ``ScrollBar``)
+- ``get_expanding()`` → ``(False, False)``
+- ``get_enabled()`` → ``True``
+- ``get_state()`` → ``False``
+- ``get_volume()`` → ``1.0`` (HTMLMediaElement convention: 0.0
+  muted, 1.0 full).
+
+Configured in ``STATE_KEY_DEFAULTS`` / ``STATE_DEFAULTS`` in
+``method_types.py``.
+
+----
+
+Earlier — since ``v0.1.3``
+--------------------------
 
 Major changes
--------------
+~~~~~~~~~~~~~
 
 TreeView / TableView: dict-tree model
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Mirroring the JS-side rewrite, ``TreeView`` and ``TableView`` now
 work with hierarchies of dicts keyed by stable string identifiers.
@@ -63,7 +126,7 @@ Highlights:
 See :doc:`widgets` for the full reference.
 
 Window controls (TopLevel) and shade (MDISubWindow)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 ``TopLevel`` gains the same window controls that ``MDISubWindow``
 has, plus a "shade" (roll up to title bar) state on both.
@@ -96,7 +159,7 @@ Maximize, Close).  The menu supports both click-release and
 press-drag-release, like a menubar.
 
 Image: binary-frame protocol
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 New method ``Image.set_binary_image(data, format='jpeg')`` sends raw
 bytes (``bytes`` / ``bytearray`` / ``memoryview``) via a WebSocket
@@ -106,7 +169,7 @@ Useful for animation/streaming.  ``format`` is one of ``"jpeg"``,
 widget state and replayed on reconnect.
 
 Callbacks base class
-~~~~~~~~~~~~~~~~~~~~
+^^^^^^^^^^^^^^^^^^^^
 
 New module ``pgwidgets.callbacks`` exposes ``Callbacks``, a small
 base class that provides the same callback API (``add_callback``,
@@ -121,7 +184,7 @@ supports both ``add_callback("activated", ...)`` and
 See :ref:`callbacks-base`.
 
 Robustness improvements
------------------------
+~~~~~~~~~~~~~~~~~~~~~~~
 
 - ``Session._send`` and ``_send_binary`` no longer hang when the
   asyncio loop refuses a coroutine (loop closed mid-call,
@@ -139,7 +202,7 @@ Robustness improvements
   internal ``ScrollBar`` widgets in its constructor.
 
 Other notable changes
----------------------
+~~~~~~~~~~~~~~~~~~~~~
 
 - ``ColorDialog`` now exposes ``popup``, ``set_position``,
   ``set_modal``, and the ``move`` / ``close`` callbacks (inherited
@@ -160,3 +223,7 @@ Other notable changes
   though the JS side preserves columns on clear).
 - ``FileBrowser`` migrated to the new dict-tree ``TableView`` API
   internally and now subclasses ``Callbacks``.
+- ``FixedLayout`` container added (auto-generated from the JS
+  definition).  Use ``W.FixedLayout()`` and
+  ``layout.add_widget(child, x, y)`` to place children at fixed
+  pixel offsets; ``remove(child)`` works as on any other container.

{pgwidgets_python-0.2.0 → pgwidgets_python-0.2.3}/docs/widgets.rst

@@ -140,6 +140,17 @@ Grid layout.
   ``append_column(widgets)``, ``delete_column(index)``
 - **Callbacks:** ``child-added``, ``child-removed``
 
+FixedLayout
+~~~~~~~~~~~
+
+Absolute-positioning container.  Each child is placed at a fixed
+``(x, y)`` pixel offset within the container and renders at its
+natural size unless ``resize()`` has been called on it.
+
+- **Options:** *(none)*
+- **Methods:** ``add_widget(child, x, y)``
+- **Callbacks:** ``child-added``, ``child-removed``
+
 Splitter
 ~~~~~~~~
 
@@ -415,24 +426,58 @@ TextSource
 
 Source code editor with line numbers, syntax tags, and gutter icons.
 
+Positions in the buffer are expressed as ``TextBufferRef`` instances —
+live references that track edits.  ``create_ref(offset, gravity)`` is
+the only place a caller deals in raw integer offsets; all other
+position-taking and position-returning methods on the public API use
+refs.
+
+.. note::
+
+   Refs are JS-side live objects.  When using ``TextSource`` over the
+   remote interface (pgwidgets-python proper), refs cannot currently
+   round-trip across the wire — a ref-handle protocol is planned for
+   a future release.  In the meantime, the ref-based API is fully
+   usable from JS-direct and pyodide contexts.
+
 - **Args:** ``text``
 - **Options:** ``wrap``, ``line_numbers``, ``icon_gutter``, ``editable``,
   ``font_family``, ``font_size``
 - **Methods:** ``set_text(text)``, ``get_text()``, ``get_length()``,
-  ``insert_text(offset, text, tags)``, ``delete_range(start, end)``,
+  ``get_text_range(start_ref, end_ref)``,
+  ``insert_text(ref, text, tags)``, ``delete_range(start_ref, end_ref)``,
   ``clear()``, ``set_editable(tf)``, ``set_wrap(mode)``,
   ``set_line_numbers(tf)``, ``set_icon_gutter(tf)``,
-  ``set_icon(line, icon_url)``, ``get_cursor()``, ``set_cursor(offset)``,
-  ``get_selection()``, ``set_selection(start, end)``,
+  ``set_icon(ref, icon_url)``, ``get_cursor()``, ``set_cursor(ref)``,
+  ``get_selection_range()``, ``set_selection_range(start_ref, end_ref)``,
   ``create_tag(name, attrs)``, ``remove_tag_def(name)``,
-  ``apply_tag(name, start, end)``, ``remove_tag(name, start, end)``,
-  ``get_tags_at(offset)``, ``create_ref(offset, gravity)``,
-  ``remove_ref(ref)``, ``undo()``, ``redo()``, ``can_undo()``,
-  ``can_redo()``, ``find(query, opts)``, ``find_all(query, opts)``,
-  ``replace(query, replacement, opts)``, ``scroll_to(ref_or_offset)``,
+  ``has_tag(name)``,
+  ``apply_tag(name, start_ref, end_ref)``,
+  ``remove_tag(name, start_ref, end_ref)``,
+  ``get_tags_at(ref)``, ``get_tags_range(start_ref, end_ref)``,
+  ``create_ref(offset, gravity)``, ``remove_ref(ref)``,
+  ``create_named_ref(name, offset, gravity)``,
+  ``get_named_ref(name)``, ``remove_named_ref(name)``,
+  ``get_ref_start()``, ``get_ref_end()``, ``get_ref_bounds()``,
+  ``get_ref_line_start(lineno)``, ``get_ref_line_end(lineno)``,
+  ``undo()``, ``redo()``, ``can_undo()``, ``can_redo()``,
+  ``find(query, opts)``, ``find_all(query, opts)``,
+  ``replace(query, replacement, opts)``, ``scroll_to_ref(ref)``,
   ``scroll_to_cursor()``
-- **Callbacks:** ``changed``, ``cursor_moved``, ``line_clicked``,
-  ``icon_clicked``
+- **Callbacks:** ``changed``, ``cursor_moved`` (fires with a fresh
+  ref), ``line_clicked``, ``icon_clicked`` (fires with
+  ``(line, ref)``)
+
+A ``TextBufferRef`` itself supports the following methods:
+
+- **Inspection:** ``get_offset()``, ``get_gravity()``, ``is_valid()``,
+  ``get_line()``, ``get_line_column()``
+- **Absolute position:** ``set_offset(offset)``, ``set_line(lineno)``,
+  ``to_ref(other)``, ``copy()``
+- **Relative movement:** ``to_line_start()``, ``to_line_end()``,
+  ``to_next_line()``, ``to_prev_line()``, ``to_next_char()``,
+  ``to_prev_char()`` (movement methods clamp at buffer boundaries
+  and are no-ops past them; mutating an invalidated ref raises)
 
 Selectors
 ---------

{pgwidgets_python-0.2.0 → pgwidgets_python-0.2.3}/pgwidgets/__init__.py

@@ -16,4 +16,17 @@ Usage (asynchronous):
     top = await W.TopLevel(title="Hello", resizable=True)
     ...
     await app.run()
+
+Version:
+    import pgwidgets
+    print(pgwidgets.__version__)
 """
+
+from importlib.metadata import version as _pkg_version, PackageNotFoundError
+
+try:
+    __version__ = _pkg_version("pgwidgets")
+except PackageNotFoundError:
+    # Package not installed (e.g. running from a source checkout
+    # without `pip install -e .`).  Fall back to a sentinel.
+    __version__ = "0.0.0+unknown"

pgwidgets_python-0.2.3/pgwidgets/_json.py

@@ -0,0 +1,63 @@
+"""JSON encoding helper for the remote protocol.
+
+The wire format between Python and the browser is JSON.  The stdlib
+encoder has two issues for scientific data:
+
+1. It rejects numpy scalars other than ``np.float64`` (which inherits
+   from float), numpy arrays, and similar buffer-protocol objects —
+   silently dropping a TreeView payload that happens to contain
+   ``np.int64`` cell values.
+
+2. It writes the literal tokens ``NaN`` / ``Infinity`` / ``-Infinity``
+   for non-finite floats, which browsers' ``JSON.parse`` reject — a
+   single masked / missing cell in a float column makes the whole
+   payload silently fail to parse on the JS side.
+
+``JsonEncoder`` handles both: ``.item()`` / ``.tolist()`` fall-backs
+for numpy/pandas types, and a pre-walk that replaces non-finite floats
+with ``None`` (encoded as JSON ``null``).  Use it via
+``json.dumps(obj, cls=JsonEncoder)``.
+"""
+
+import json
+import math
+
+
+def _scrub_nan(obj):
+    """Recursively replace non-finite floats with None so the result
+    is RFC-8259-valid JSON when re-encoded.  Cheap walk: O(n) and
+    only visits dicts/lists/tuples/floats."""
+    if isinstance(obj, float):
+        return obj if math.isfinite(obj) else None
+    if isinstance(obj, dict):
+        return {k: _scrub_nan(v) for k, v in obj.items()}
+    if isinstance(obj, (list, tuple)):
+        return [_scrub_nan(v) for v in obj]
+    return obj
+
+
+def _coerce_scalar(v):
+    """If *v* is a float, replace non-finite values with None."""
+    if isinstance(v, float) and not math.isfinite(v):
+        return None
+    return v
+
+
+class JsonEncoder(json.JSONEncoder):
+    def default(self, obj):
+        item = getattr(obj, "item", None)
+        if callable(item):
+            try:
+                return _coerce_scalar(item())
+            except (TypeError, ValueError):
+                pass
+        tolist = getattr(obj, "tolist", None)
+        if callable(tolist):
+            try:
+                return _scrub_nan(tolist())
+            except (TypeError, ValueError):
+                pass
+        return super().default(obj)
+
+    def iterencode(self, o, _one_shot=False):
+        return super().iterencode(_scrub_nan(o), _one_shot=_one_shot)

{pgwidgets_python-0.2.0 → pgwidgets_python-0.2.3}/pgwidgets/async_/application.py

@@ -23,6 +23,7 @@ from pathlib import Path
 import websockets
 
 from pgwidgets_js import get_static_path, get_remote_html
+from pgwidgets._json import JsonEncoder
 from pgwidgets.defs import WIDGETS
 from pgwidgets.method_types import (
     SPECIAL_SETTERS, FIXED_SETTERS, CHILD_METHODS as CHILD_METHOD_NAMES,
@@ -90,6 +91,13 @@ class Session:
     _STATE_KEY_TO_SETTER = {v: k for k, v in SPECIAL_SETTERS.items()}
     # e.g. {"size": "resize"}
 
+    # Reverse map: state_key -> callback action that auto-syncs it
+    # (e.g. "size" -> "resize", "position" -> "move").  Used during
+    # state replay to skip keys that weren't actively opted into via
+    # _auto_sync_actions — those were captured passively for getter
+    # support but must not be replayed (would pin layout).
+    _STATE_KEY_TO_SYNC_ACTION = {v: k for k, v in STATE_SYNC_CALLBACKS.items()}
+
     # State keys handled by fixed-value methods (show/hide)
     _FIXED_STATE_KEYS = {}
     for _mname, (_key, _val) in FIXED_SETTERS.items():
@@ -299,30 +307,46 @@ class Session:
 
     def _dispatch_callback(self, wid, action, *args):
         """Dispatch a callback through the configured concurrency mode."""
-        if self._reconstructing:
-            return  # suppress callbacks during reconstruction
+        # Suppress callbacks during reconstruction — they are side
+        # effects of state replay, not user actions.  Exception: 'map'
+        # is a one-shot lifecycle event that the JS-side observers fire
+        # when a widget first gains a visible layout box; the timing
+        # can land inside the reconstruction window, and dropping it
+        # means the user's map handler never runs until a later layout
+        # change (e.g. window resize) triggers a re-fire.
+        if self._reconstructing and action != 'map':
+            return
 
         # Auto-sync: some callbacks carry state that should be reflected
         # in the Python-side widget (e.g. move -> position, resize -> size).
+        # We always *capture* the value so get_size()/get_position() return
+        # current values, but only *push* it to other browsers (and replay
+        # it on reconstruction) when the widget opted in via auto-sync.
+        # Otherwise a layout-determined size would replay as a literal
+        # resize(W, H) — pinning the widget to pixel dimensions and
+        # killing flex growth.
         state_key = STATE_SYNC_CALLBACKS.get(action)
         if state_key is not None:
             widget = self._widget_map.get(wid)
             if widget is not None:
+                auto = action in widget._auto_sync_actions
                 if len(args) == 1 and isinstance(args[0], dict):
                     d = args[0]
                     if "width" in d and "height" in d:
                         new_val = (d["width"], d["height"])
                         if widget._state.get(state_key) != new_val:
                             widget._state[state_key] = new_val
-                            self._push(wid, "resize",
-                                       d["width"], d["height"])
+                            if auto:
+                                self._push(wid, "resize",
+                                           d["width"], d["height"])
                 else:
                     new_val = tuple(args)
                     if widget._state.get(state_key) != new_val:
                         widget._state[state_key] = new_val
-                        setter = (self._STATE_KEY_TO_SETTER.get(state_key)
-                                  or f"set_{state_key}")
-                        self._push(wid, setter, *args)
+                        if auto:
+                            setter = (self._STATE_KEY_TO_SETTER.get(state_key)
+                                      or f"set_{state_key}")
+                            self._push(wid, setter, *args)
                 # If this widget wraps a child (e.g. MDISubWindow),
                 # propagate geometry into the parent's children options
                 # so reconstruction replays with the current pos/size.
@@ -492,7 +516,7 @@ class Session:
         self._next_id += 1
         msg["id"] = msg_id
         try:
-            payload = json.dumps(msg)
+            payload = json.dumps(msg, cls=JsonEncoder)
         except Exception as e:
             self._logger.error(
                 f"JSON encode failed for "
@@ -510,7 +534,7 @@ class Session:
             ff_id = self._next_id
             self._next_id += 1
             msg_copy = dict(msg, id=ff_id)
-            ff_payload = json.dumps(msg_copy)
+            ff_payload = json.dumps(msg_copy, cls=JsonEncoder)
             for ws in self._connections[1:]:
                 _schedule_ws_send(ws, ff_payload)
         result = await future
@@ -541,7 +565,7 @@ class Session:
                 "method": method,
                 "args": list(args),
                 "silent": True,
-            })
+            }, cls=JsonEncoder)
         except Exception as e:
             self._logger.error(
                 f"JSON encode failed for push {method} "
@@ -567,7 +591,7 @@ class Session:
             "id": msg_id,
             "wid": wid,
             "action": action,
-        })
+        }, cls=JsonEncoder)
         for ws in self._connections:
             _schedule_ws_send(ws, payload)
 
@@ -630,7 +654,7 @@ class Session:
             "wid": wid,
             "method": method,
             "args": list(args),
-        })
+        }, cls=JsonEncoder)
         async def _pair(ws):
             await ws.send(header)
             await ws.send(data)
@@ -734,17 +758,37 @@ class Session:
             cls = self._widget_classes.get(cls_name, Widget) if cls_name else Widget
             widget = cls._from_existing(self, wid, cls_name or "Widget")
             self._widget_map[wid] = widget
-            # Auto-listen for state-syncing callbacks (move, resize)
-            # so position/size changes are tracked for reconstruction.
+            # Auto-listen for state-syncing callbacks (move, resize).
             # Register locally (sync) and send the listen message as
             # true fire-and-forget (no result awaited) since
-            # _resolve_return is not async.
+            # _resolve_return is not async.  For visual widgets we
+            # always listen for 'resize' so get_size() can return a
+            # current value, but we only mark the action as
+            # auto-syncing (which triggers push-to-peers and
+            # replay-on-reconstruction) when the widget defn opts in.
+            # Non-visual Callback-base objects (Timer, TextBufferRef,
+            # …) get nothing.
+            defn = WIDGETS.get(cls_name, {}) if cls_name else {}
+            opt_names_set = set(defn.get("options", []))
+            all_callbacks = defn.get("callbacks", [])
+            is_visual = defn.get("base") != "callback"
             for action in STATE_SYNC_CALLBACKS:
-                key = f"{wid}:{action}"
-                if key not in self._callbacks:
-                    self._callbacks[key] = [lambda wid, *a: None]
-                    self._fire_and_forget_listen(wid, action)
-                widget._auto_sync_actions.add(action)
+                req_opt = STATE_SYNC_REQUIRES_OPTION.get(action)
+                if req_opt is not None:
+                    opted_in = req_opt in opt_names_set
+                else:
+                    opted_in = action in all_callbacks
+                if not is_visual:
+                    continue
+                if action == "resize" or opted_in:
+                    key = f"{wid}:{action}"
+                    if key not in self._callbacks:
+                        self._callbacks[key] = [lambda wid, *a: None]
+                        self._fire_and_forget_listen(wid, action)
+                if opted_in:
+                    widget._auto_sync_actions.add(action)
+                elif action == "resize":
+                    widget._passive_sync_actions.add(action)
             return widget
         if isinstance(val, list):
             return [self._resolve_return(v) for v in val]
@@ -838,12 +882,23 @@ class Session:
                 await self._listen(new_widget._wid, act,
                                    lambda wid, *a: None)
                 new_widget._auto_sync_actions.add(act)
-        # Replay any state the proxy accumulated (e.g. set_tooltip)
+        # Replay any state the proxy accumulated (e.g. set_tooltip).
+        # Skip passively-captured auto-sync state (size, position): we
+        # capture those from callbacks so getters work, but replaying
+        # would pin the widget to layout-determined pixel dimensions
+        # (same logic as _reconstruct_widget).
+        user_set = getattr(old_widget, "_user_set_state", set())
+        auto = getattr(old_widget, "_auto_sync_actions", set())
         for key, value in old_widget._state.items():
             if key.startswith("_"):
                 continue
             if key in sync_keys:
                 continue
+            sync_action = self._STATE_KEY_TO_SYNC_ACTION.get(key)
+            if (sync_action is not None
+                    and key not in user_set
+                    and sync_action not in auto):
+                continue
             method_name = (self._STATE_KEY_TO_SETTER.get(key)
                            or f"set_{key}")
             if isinstance(value, tuple):
@@ -851,6 +906,13 @@ class Session:
             else:
                 await self._call(new_widget._wid, method_name, value)
             new_widget._state[key] = value
+            # Propagate user-set / auto-sync membership to the new
+            # widget so subsequent reconstructions replay consistently.
+            if sync_action is not None:
+                if key in user_set:
+                    new_widget._user_set_state.add(key)
+                if sync_action in auto:
+                    new_widget._auto_sync_actions.add(sync_action)
 
     async def _ensure_reconstructed(self, widget):
         """Ensure a widget has been created on the JS side."""
@@ -1002,6 +1064,20 @@ class Session:
             if key.startswith("_"):
                 continue
 
+            # Skip auto-sync state (size, position) that came in
+            # passively via a callback (e.g. layout-determined size).
+            # We capture those so getters like get_size()/
+            # get_position() work, but replaying them would pin the
+            # widget to pixel dimensions and override flex/expanding
+            # layout.  Replay only if the user explicitly set the
+            # value, or if the widget opted into the sync action
+            # (e.g. an interactively-resizable widget).
+            sync_action = self._STATE_KEY_TO_SYNC_ACTION.get(key)
+            if (sync_action is not None
+                    and key not in widget._user_set_state
+                    and sync_action not in widget._auto_sync_actions):
+                continue
+
             # Binary-payload state (e.g. set_binary_image) replays via
             # _send_binary so the bytes go in a raw frame, not embedded
             # as base64 in JSON.
@@ -1046,10 +1122,13 @@ class Session:
         # _listen calls treat them as first-time registrations and
         # actually send the "listen" message to the browser.
         wid = widget._wid
+        passive = getattr(widget, "_passive_sync_actions", set())
         for action in list(saved_cbs.keys()):
             self._callbacks.pop(f"{wid}:{action}", None)
         for action in widget._auto_sync_actions:
             self._callbacks.pop(f"{wid}:{action}", None)
+        for action in passive:
+            self._callbacks.pop(f"{wid}:{action}", None)
 
         for action, entries in saved_cbs.items():
             for handler, extra_args, extra_kwargs, style in entries:
@@ -1066,6 +1145,13 @@ class Session:
             if action not in widget._registered_callbacks:
                 await self._listen(widget._wid, action,
                                    lambda wid, *a: None)
+        # Passive listeners (e.g. 'resize' for getter support on
+        # widgets that didn't opt into auto-sync).
+        for action in passive:
+            if (action not in widget._registered_callbacks
+                    and action not in widget._auto_sync_actions):
+                await self._listen(widget._wid, action,
+                                   lambda wid, *a: None)
 
     async def reconstruct(self):
         """Replay the entire widget tree to all connected browsers.
@@ -1332,7 +1418,8 @@ class Application:
     async def _ws_handler(self, ws):
         # Init handshake: send init, receive ack which may contain
         # session_id + token for reconnection.
-        await ws.send(json.dumps({"type": "init", "id": 0}))
+        await ws.send(json.dumps({"type": "init", "id": 0},
+                                 cls=JsonEncoder))
         ack_data = await ws.recv()
         ack = json.loads(ack_data)
         reconnect_sid = ack.get("session_id")
@@ -1399,7 +1486,7 @@ class Application:
             "type": "session-info",
             "session_id": session.id,
             "token": session.token,
-        }))
+        }, cls=JsonEncoder))
 
         if is_reconnect:
             async def do_reconstruct():