In the examples there is no demonstration of what appears to be the suggested primary workflow/organisation of files/code.
We see this discussed over time in several places but no extent demo exists.
Ideally there would be three or four templates which a user could use to start from.

Ideal workflow seems to be:

1. main.py is an mpy
2. Work that needs more capability is done on workers (pyodide where required else mpy)
3. The workers either directly adj the main's dom or send data back to the main for it to adjust its own dom.

Within this structure its not necessarily clear whether there is a method for moving large amounts of data between js/python so it can be maximally efficient. (e.g. canvas draw calls)
Its also unclear if starting a pyodide worker from inside the main.mpy is "better" than starting it in the index.html.

So I propose the following templates and an example app to exercise them:

Templates:

1. main.py(mpy), worker.py(pyo) that directly updates dom id fields.
2. Same but data is sent back to main, with no dom manipulation by the worker.
   • I.e. where main further manipulates and updates the dom itself.
3. More than one Worker (perhaps one fetches some data, and another processes it using a module (like the many pandas examples))

Example problem

To make an interesting but useful demo I suggest the following structure/tasks:

1. main.py(mpy) has buttons and a canvas
2. main asks a worker to build a datastructure (the two-worker variant has it getting this data from a fetch worker)
3. main asks the worker to manipulate this data and create svg elements.
4. main needs these in an Image format to draw them on the canvas
   4a. the worker makes these into images and draws them directly on the canvas, or
   4b. the images get transferred back to main which draws them on the canvas
5. main ui buttons enable initiating the two worker actions and doing other canvas ops locally.
   5a. Could add timing if we wanted to see if one path or another was faster.

A demo like this would show:

• several examples of increasing complexity (2 workers, js data transfer, dom manip in worker, fetch example, worker sync.)
• something with responsive visual feedback
• when we need to show wait animations and how to handshake waiting until the worker is 'ready to run' / 'data is ready'

There is a start at this here:

• https://pyscript.com/@neon22/mpy-master-template/latest?files=main.py