PyScript Next runtime configuration: Global namespace synchronization across backends

Direct Answer: Synchronization Consistency

In PyScript Next, the synchronization of the Python global namespace with the JavaScript window object is not consistent across Pyodide and MicroPython backends. While the <py-config> tag handles environment setup, the underlying mechanism for object exposure and interoperability differs significantly due to the architecture of each runtime.

Backend Differences in Namespace Mapping

The uncertainty stems from how each runtime handles the bridge between Python memory and the JavaScript engine:

• Pyodide: Uses a robust WebAssembly-based bridge. When you expose Python objects to the window, Pyodide creates proxy objects that allow for deep interaction. It supports complex C-extension-based libraries but carries higher memory overhead for each synchronized object.
• MicroPython: Uses a much lighter implementation designed for small footprints. It lacks the full C-extension support found in Pyodide. Mapping complex Python globals to JavaScript often requires manual serialization or simplified wrappers, as the interoperability layer is optimized for speed over depth.

Constraints for Backend-Agnostic Configuration

When writing a configuration intended to work across both backends, consider these specific constraints:

1. Object Complexity: Avoid mapping complex class instances or objects with heavy methods to the window. Stick to primitive types (dictionaries, lists, strings) that represent global state.
2. Asynchronous Behavior: Pyodide handles asynchronous proxies differently than MicroPython. Code that relies on a global variable being updated via a JS callback may fail or experience race conditions in the MicroPython environment.
3. Library Availability: If synchronization depends on Pyodide-specific modules (like NumPy or Pandas), the configuration will fail on the MicroPython backend as these libraries are not natively available or synchronized in the same manner.

Recommended Strategy

To maintain a backend-agnostic environment, do not rely on the runtime's automatic global exposure. Instead, use an explicit state-management pattern:

// Explicitly sync state in JS
function syncToJS(data) {
    window.pyAppState = data;
}

// In Python
from pyscript import window
import json

def update_state(new_val):
    window.pyAppState = json.dumps(new_val)

Are you attempting to synchronize real-time data streams between multiple users, or just local configuration on load?