release_note: add 0.1.1 entry

Adds Flatpak/AppImage to the channels table, documents the host-only
contract and bins.py mechanics, explains the runtime-aware run launcher.

.gitignore

@@ -8,6 +8,8 @@ dist
 /.vscode
 .venv/
 .flatpak-builder/
+package/flatpak/repo/
+package/flatpak/*.flatpak
 crash.tx*
 report_test.tx*
 *.autosave
@@ -24,6 +26,7 @@ package/appimage/*.AppImage
 package/appimage/src
 package/appimage/*.py
 AppDir
+*.squashfs
 doc/manual/doxygen
 doc/manual/sphinx/build/*
 doc/manual/sphinx/source/_build/*

CLAUDE.md

@@ -183,6 +183,8 @@ Icons are assigned once when the test file is loaded (not updated live on theme
 
 The sub-test's own pass/fail result is intentionally not propagated.
 
+The interpreter and entry point used to spawn the sub-instance are picked automatically by `_testium_launch_cmd()` based on how the parent was started (AppImage → `$APPIMAGE`; Flatpak → `flatpak run`; PyInstaller → the frozen binary; source/wheel → `[sys.executable, abspath(sys.argv[0])]`). The user cannot override either via the YAML — selecting a different testium binary or Python from a sub-test was removed because it was either ill-defined (bundle modes have no separable Python) or could mismatch the parent's environment in surprising ways.
+
 ### Report exporters & plugins
 `src/testium/interpreter/test_report/test_report.py` — `_EXPORTER_REGISTRY` dict maps a format name (cmd key in the YAML `report.export`) to a lazy loader. Built-ins: `text`, `json`, `junit` (needs `junit_xml`), `html` (needs `lxml`). `sqlite` is the storage layer, no-op as an export.
 
@@ -201,17 +203,38 @@ A real-world test plugin lives at `test/validation/fake_exporter/` (CSV exporter
 
 ## Packaging
 
-Three distribution channels coexist, sharing the single `src/testium/` package:
+Four distribution channels coexist, all sharing the single `src/testium/` package and the single `src/requirements.txt` dependency list:
 
-| Channel | Where | Notes |
+| Channel | Where | Build | Notes |
-|---------|-------|-------|
+|---------|-------|-------|-------|
-| Wheel (`pip install`) | `src/pyproject.toml` | Vanilla Python package; entry point `testium = "testium:main"` |
+| Wheel (`pip install`) | `src/pyproject.toml` | `python -m build` | Vanilla Python package; entry point `testium = "testium:main"`. |
-| PyInstaller binary | `package/pyinstaller/` | Single ~130 MB binary. `py_func`, `runtime`, `lua_func` bundled at `_MEIPASS` root so the **host** Python can find them when launched as `python3 py_func`. `api`/`interpreter` are **not** exposed (subprocess isolation). |
+| PyInstaller binary | `package/pyinstaller/` | `build.sh` | Single ~130 MB binary. `py_func`, `runtime`, `lua_func` bundled at `_MEIPASS` root so the **host** Python can find them when launched as `python3 py_func`. `api`/`interpreter` are **not** exposed (subprocess isolation). |
-| Flatpak | `package/flatpak/` | (Existing recipe, not actively maintained in current refactor wave.) |
+| Flatpak | `package/flatpak/` | `build.sh` (uses `flatpak-builder`) | KDE 6.10 runtime. The bundled Python runs only the main process; `py_func` / `lua_func` MUST run under the **host** interpreter (no Python/Lua bundled). Produces a distributable `.flatpak` bundle. |
+| AppImage | `package/appimage/` | `build.sh` (Debian Bookworm container via Podman/Docker) | Bundles Python 3.11 for the main process; `py_func` / `lua_func` MUST run under the **host** interpreter. Build runs in a container so it works on Arch / any non-Debian host. |
 
 The `.deb` work-in-progress lives in `package/deb/`:
 - `test_distro.sh debian:bookworm | debian:trixie | ubuntu:24.04` spins up a Docker/Podman container, reports system package availability, falls back to pip for what's missing (`pyside6` on bookworm/ubuntu, `telnetlib3`, `junit_xml`), runs the validation suite. Currently green on the three targets.
 
+### Host-only py_func / lua_func in sandboxed bundles (Flatpak, AppImage)
+
+The bundled Python (Flatpak's runtime python, AppImage's `python3.11`) is reserved for the **main process only**. Subprocesses (`py_func`, `lua_func`, `git`) must use the host's interpreters and tools so user-installed modules (pyserial, junit_xml, …) are visible. This is enforced by `interpreter/utils/bins.py`:
+
+- `_in_flatpak()` (checks `/.flatpak-info`) and `_in_appimage()` (checks `APPIMAGE` env var) detect the sandbox.
+- `_which(name)` probes only host bin dirs in those modes:
+  - Flatpak: `/run/host/usr/{local/,}bin`, `/run/host/bin` (host mounted via `--filesystem=host-os`).
+  - AppImage: `/usr/local/bin`, `/usr/bin`, `/bin` (we are directly on the host filesystem).
+  - If the host has no python3/lua, `ensure()` raises `ETUMRuntimeError` at test load with the candidate list — no silent fallback to a bundled interpreter.
+- User overrides (`python_bin`/`lua_bin` in globdict): bare names are resolved through `_which()` (host-only), absolute paths are accepted as-is.
+- `apply_host_libs(env)` is called by `py_process.py` / `lua_process.py` on the env passed to Popen:
+  - Flatpak: prepends host lib dirs to `LD_LIBRARY_PATH` so the dynamic linker finds host `.so`'s.
+  - AppImage: strips `$APPDIR`-prefixed entries from `LD_LIBRARY_PATH` / `PYTHONPATH` / `PATH` and drops `PYTHONHOME`, so the host Python doesn't try to load the bundled stdlib/site-packages.
+- `apply_host_lua_paths(env)` (Flatpak only) prepends `/run/host/usr/{lib,share}/lua/X.Y` to `LUA_PATH` / `LUA_CPATH` so `cjson`, `socket`, etc. resolve. Must be called **after** user `lua_env` overrides so host paths win. AppImage relies on host Lua's compiled-in defaults.
+- `py_process.py` additionally pops `PYTHONUSERBASE` (set to `/var/data/python` by the Flatpak runtime, which would hide `~/.local/lib/...`).
+
+### Version reporting (`interpreter/utils/version.py`)
+
+Both Flatpak and AppImage export `TESTIUM_VERSION` from a launcher (Flatpak: launcher script in `org.testium.Testium.yaml`; AppImage: `runtime.env` in `AppImageBuilder.yml`). `get_testium_version()` checks `/.flatpak-info` / `APPIMAGE` and reads `TESTIUM_VERSION` rather than relying on package metadata or repo introspection.
+
 ## Recent fixes / notable changes
 - Restructure: single `src/testium/` Python package (was 4 sibling top-levels: `testium`, `lib`, `py_func`, `lua_func`). `lib/` → `runtime/`, `libs/` → `api/`. `pip install` now produces a clean `site-packages/testium/` with no top-level pollution; `.lua` files travel via `package_data`.
 - `bins.py`: centralised resolution + cache of external `python3` / `lua` binaries. Replaces the scattered `tm.gd("python_bin")`/`tm.gd("lua_bin")` dance and the duplicated discovery logic in `py_process.py`/`lua_process.py`. Validates at test load via `TestSet._validate_runtime_deps()` so missing interpreters fail fast.

README.md

@@ -27,7 +27,19 @@ Pre-built artifacts are published at
   runnable directly, no Python installation required on the host. Lua
   support still needs a system `lua` interpreter and the `lua-socket` /
   `lua-cjson` modules.
-* **Flatpak** — *coming soon.*
+* **Flatpak bundle** (`testium.flatpak`) — install with:
+
+  ```sh
+  # Add Flathub (once, to fetch the KDE/PySide runtimes)
+  flatpak remote-add --user --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
+
+  # Install the bundle
+  flatpak install --user testium.flatpak
+  ```
+
+  After installation testium appears in the desktop application menu and the
+  `testium` command is available in the terminal (requires `~/.local/bin` in
+  `PATH`, which most modern distributions provide by default).
 
 ## Quick start
 

package/appimage/AppImageBuilder.yml

@@ -24,9 +24,8 @@ AppDir:
 
     runtime:
         env:
-            SEQUENCER_REV: '{{APP_VERSION}}'
+            TESTIUM_VERSION: '{{APP_VERSION}}'
             PYTHONPATH: $APPDIR/usr/lib/python3.11/site-packages:$APPDIR/usr/lib/python3.11
-            QT_QPA_PLATFORM: xcb
 
         path_mappings:
             - /usr/share/matplotlib/mpl-data/matplotlibrc:$APPDIR/etc/matplotlibrc
@@ -69,12 +68,13 @@ AppDir:
 
         # Set python 3.11 as default
         ln -fs python3.11 $TARGET_APPDIR/usr/bin/python3
-        # Install pip
+
-        if [ ! -f "get-pip.py" ]; then curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py; fi
+        # Bootstrap pip into the AppDir Python
+        if [ ! -f "get-pip.py" ]; then curl -sS https://bootstrap.pypa.io/get-pip.py -o get-pip.py; fi
         python3.11 get-pip.py --break-system-packages
 
         # Install application dependencies in AppDir
-        python3.11 -m pip install --break-system-packages --upgrade --isolated --no-input --ignore-installed --prefix=$TARGET_APPDIR/usr -r requirements.txt
+        python3.11 -m pip install --break-system-packages --upgrade --isolated --no-input --ignore-installed --prefix=$TARGET_APPDIR/usr -r ../../src/requirements.txt
 
         export PIP_CONFIG_FILE=$HOME/.pip/pip.conf
         python3.11 -m pip install --break-system-packages --upgrade --isolated --no-input --ignore-installed --prefix=$TARGET_APPDIR/usr ../../src/dist/testium-{{APP_VERSION}}-py3-none-any.whl

package/appimage/build.sh

@@ -1,12 +1,53 @@
-#!/usr/bin/bash
+#!/bin/bash
+# Build the testium AppImage inside a Debian container (Podman or Docker).
+# The resulting .AppImage file is written to this directory.
 
-export APP_VERSION=$(<../../src/VERSION)
+set -e
 
-appimage-builder --recipe AppImageBuilder.yml
+REPO_ROOT="$(cd "$(dirname "$0")/../.." && pwd)"
+APP_VERSION="$(<"$REPO_ROOT/src/VERSION")"
 
-RESULT=$?
+if command -v podman &>/dev/null; then
-if [ -n "$1" ] && [ "$1" = "install" ]; then
+    RUNTIME=podman
-    if [ $RESULT -eq 0 ]; then
+elif command -v docker &>/dev/null; then
-        install -v "testium-${APP_VERSION}-x86_64.AppImage" "${HOME}/.local/bin/testium"
+    RUNTIME=docker
-    fi
+else
+    echo "Error: neither podman nor docker found." >&2
+    exit 1
+fi
+echo "Using $RUNTIME — building testium $APP_VERSION AppImage..."
+
+# APPIMAGE_EXTRACT_AND_RUN=1 lets appimagetool run without FUSE in the container.
+$RUNTIME run --rm \
+    --privileged \
+    -e APPIMAGE_EXTRACT_AND_RUN=1 \
+    -v "$REPO_ROOT:/work" \
+    -w /work/package/appimage \
+    debian:bookworm bash -c "
+        set -e
+        export DEBIAN_FRONTEND=noninteractive
+
+        apt-get update -qq
+        apt-get install -y -qq \
+            python3 python3-pip python3-venv python3-build \
+            dpkg-dev fakeroot squashfs-tools wget curl file binutils \
+            libglib2.0-0 patchelf zsync > /dev/null
+
+        # Build the wheel
+        cd /work/src
+        python3 -m build --wheel --outdir dist/ > /dev/null
+        cd /work/package/appimage
+
+        # Install appimage-builder
+        pip3 install appimage-builder --quiet --break-system-packages
+
+        # Run the build
+        export APP_VERSION=$APP_VERSION
+        appimage-builder --recipe AppImageBuilder.yml --skip-test
+    "
+
+echo "Done: testium-${APP_VERSION}-x86_64.AppImage"
+
+if [ "${1}" = "install" ]; then
+    install -v "testium-${APP_VERSION}-x86_64.AppImage" "${HOME}/.local/bin/testium"
 fi

package/appimage/requirements.txt

@@ -1,3 +0,0 @@
-tables
-pandas
-scapy

package/flatpak/build.sh

@@ -5,4 +5,22 @@
 # flatpak install flathub org.kde.Sdk//6.10
 # flatpak install flathub io.qt.PySide.BaseApp//6.10
 
-flatpak-builder --user --verbose --force-clean --install build org.testium.Testium.yaml
+set -e
+
+# Build + install local
+flatpak-builder --user --verbose --force-clean --install --repo=repo build org.testium.Testium.yaml
+
+# Génère le bundle distribuable
+flatpak build-bundle repo testium.flatpak org.testium.Testium
+echo "Bundle généré : $(pwd)/testium.flatpak"
+
+# Crée ~/.local/bin/testium pour pouvoir taper "testium" en console
+WRAPPER="$HOME/.local/bin/testium"
+mkdir -p "$HOME/.local/bin"
+cat > "$WRAPPER" <<'EOF'
+#!/bin/sh
+exec flatpak run org.testium.Testium "$@"
+EOF
+chmod +x "$WRAPPER"
+echo "Wrapper installé : $WRAPPER"
+echo "Assurez-vous que ~/.local/bin est dans votre PATH."

package/flatpak/org.testium.Testium-mime.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<mime-info xmlns="http://www.freedesktop.org/standards/shared-mime-info">
+  <mime-type type="application/x-testium">
+    <comment>Testium test script</comment>
+    <glob pattern="*.tum"/>
+  </mime-type>
+</mime-info>

package/flatpak/org.testium.Testium.desktop

@@ -0,0 +1,10 @@
+[Desktop Entry]
+Name=Testium
+GenericName=Test Sequencer
+Comment=YAML-based test sequencer and runner
+Exec=testium %f
+Icon=org.testium.Testium
+Type=Application
+Categories=Development;
+MimeType=application/x-testium;
+StartupNotify=true

package/flatpak/org.testium.Testium.yaml

@@ -13,7 +13,9 @@ finish-args:
   - --socket=wayland
   - --device=dri
   - --share=network
-  - --filesystem=home # Optionnel : si votre testium doit lire des fichiers utilisateurs
+  - --filesystem=home
+  - --filesystem=/tmp
+  - --filesystem=host-os
 
 build-options:
   build-args:
@@ -41,18 +43,41 @@ modules:
     sources:
       - type: dir
         path: ../../src
+      - type: file
+        path: org.testium.Testium.desktop
+      - type: file
+        path: org.testium.Testium-mime.xml
+      - type: file
+        path: ../../package/testium.png
     build-commands:
-      # On installe le code source dans /app/lib/testium
+      # Code source
       - mkdir -p /app/lib
-      - cp -r . /app/lib/
+      - cp -r testium /app/lib/
+      - cp VERSION /app/lib/testium/VERSION
 
-      # Création du launcher exécutable
+      # Launcher exécutable
       - mkdir -p /app/bin
       - |
         cat <<EOF > /app/bin/testium
         #!/bin/sh
-        # On ajoute le code source et l'extension PySide6 au PYTHONPATH
+        export TESTIUM_VERSION="\$(cat /app/lib/testium/VERSION 2>/dev/null || echo unknown)"
         export PYTHONPATH="/app/lib/testium:/usr/lib/sdk/pyside6/lib/python3.13/site-packages:\$PYTHONPATH"
-        exec python3 /app/lib/testium "\$@"
+        # Expose host binaries (git, python3, lua, …) for subprocess lookups.
+        # PATH is appended (not prepended) so the main process keeps the sandbox python3.
+        export PATH="\$PATH:/run/host/usr/local/bin:/run/host/usr/bin:/run/host/bin"
+        export GIT_PYTHON_GIT_EXECUTABLE="/run/host/usr/bin/git"
+        exec /usr/bin/python3 /app/lib/testium "\$@"
         EOF
       - chmod +x /app/bin/testium
+
+      # Icône
+      - mkdir -p /app/share/icons/hicolor/256x256/apps
+      - cp testium.png /app/share/icons/hicolor/256x256/apps/org.testium.Testium.png
+
+      # Entrée menu
+      - mkdir -p /app/share/applications
+      - cp org.testium.Testium.desktop /app/share/applications/
+
+      # Type MIME pour .tum
+      - mkdir -p /app/share/mime/packages
+      - cp org.testium.Testium-mime.xml /app/share/mime/packages/

release_note.txt

@@ -1,3 +1,24 @@
+version 0.1.1
+==============
+- Packaging: Flatpak bundle (desktop entry, MIME, distributable .flatpak)
+  and AppImage (containerized build, runs on Arch / non-Debian hosts).
+- bins.py: host-only Python/Lua resolution from sandboxed bundles
+  (Flatpak / AppImage); fail fast at test load if the host interpreter
+  is missing.
+- run item: runtime-aware launcher (AppImage / Flatpak / PyInstaller /
+  source / wheel); drop testium_path / python_bin parameters.
+- dialog_env: auto-detect Wayland vs xcb from $DISPLAY / $WAYLAND_DISPLAY
+  instead of forcing xcb (was hanging dialogs on pure-Wayland sessions).
+- version: read TESTIUM_VERSION env in Flatpak/AppImage so the About
+  dialog stops reporting "unknown".
+- runtime_plot last_values: bump timeout 1s -> 5s and narrow the bare
+  except to queue.Empty.
+- py_func/__main__: robust sys.path init, diagnostic on import failure.
+- Subprocess stdio (py_func / lua_func) routed into the parent log.
+- README refocused on users (quick_start, tutorial); CONTRIBUTING filled.
+- Docs: CLAUDE.md Packaging section rewritten.
+- LICENSE file (EUPL-1.2) added.
+
 version 0.1
 ==============
 - Start of the project

src/LICENSE

@@ -0,0 +1,315 @@
+Copyright (c) 2025-2026 François Dausseur
+
+Licensed under the EUPL
+
+
+                       EUROPEAN UNION PUBLIC LICENCE v. 1.2
+                       EUPL © the European Union 2007, 2016
+
+This European Union Public Licence (the 'EUPL') applies to the Work (as
+defined below) which is provided under the terms of this Licence. Any use of
+the Work, other than as authorised under this Licence is prohibited (to the
+extent such use is covered by a right of the copyright holder of the Work).
+
+The Work is provided under the terms of this Licence when the Licensor (as
+defined below) has placed the following notice immediately following the
+copyright notice for the Work:
+
+        Licensed under the EUPL
+
+or has expressed by any other means his willingness to license under the EUPL.
+
+
+1. Definitions
+
+In this Licence, the following terms have the following meaning:
+
+- 'The Licence': this Licence.
+
+- 'The Original Work': the work or software distributed or communicated by the
+  Licensor under this Licence, available as Source Code and also as Executable
+  Code as the case may be.
+
+- 'Derivative Works': the works or software that could be created by the
+  Licensee, based upon the Original Work or modifications thereof. This Licence
+  does not define the extent of modification or dependence on the Original
+  Work required in order to classify a work as a Derivative Work; this extent
+  is determined by copyright law applicable in the country mentioned in
+  Article 15.
+
+- 'The Work': the Original Work or its Derivative Works.
+
+- 'The Source Code': the human-readable form of the Work which is the most
+  convenient for people to study and modify.
+
+- 'The Executable Code': any code which has generally been compiled and which
+  is meant to be interpreted by a computer as a program.
+
+- 'The Licensor': the natural or legal person that distributes or communicates
+  the Work under the Licence.
+
+- 'Contributor(s)': any natural or legal person who modifies the Work under
+  the Licence, or otherwise contributes to the creation of a Derivative Work.
+
+- 'The Licensee' or 'You': any natural or legal person who makes any usage of
+  the Work under the terms of the Licence.
+
+- 'Distribution' or 'Communication': any act of selling, giving, lending,
+  renting, distributing, communicating, transmitting, or otherwise making
+  available, online or offline, copies of the Work or providing access to its
+  essential functionalities at the disposal of any other natural or legal
+  person.
+
+
+2. Scope of the rights granted by the Licence
+
+The Licensor hereby grants You a worldwide, royalty-free, non-exclusive,
+sublicensable licence to do the following, for the duration of copyright
+vested in the Original Work:
+
+- use the Work in any circumstance and for all usage,
+- reproduce the Work,
+- modify the Work, and make Derivative Works based upon the Work,
+- communicate to the public, including the right to make available or display
+  the Work or copies thereof to the public and perform publicly, as the case
+  may be, the Work,
+- distribute the Work or copies thereof,
+- lend and rent the Work or copies thereof,
+- sublicense rights in the Work or copies thereof.
+
+Those rights can be exercised on any media, supports and formats, whether now
+known or later invented, as far as the applicable law permits so.
+
+In the countries where moral rights apply, the Licensor waives his right to
+exercise his moral right to the extent allowed by law in order to make
+effective the licence of the economic rights here above listed.
+
+The Licensor grants to the Licensee royalty-free, non-exclusive usage rights
+to any patents held by the Licensor, to the extent necessary to make use of
+the rights granted on the Work under this Licence.
+
+
+3. Communication of the Source Code
+
+The Licensor may provide the Work either in its Source Code form, or as
+Executable Code. If the Work is provided as Executable Code, the Licensor
+provides in addition a machine-readable copy of the Source Code of the Work
+along with each copy of the Work that the Licensor distributes or indicates,
+in a notice following the copyright notice attached to the Work, a repository
+where the Source Code is easily and freely accessible for as long as the
+Licensor continues to distribute or communicate the Work.
+
+
+4. Limitations on copyright
+
+Nothing in this Licence is intended to deprive the Licensee of the benefits
+from any exception or limitation to the exclusive rights of the rights owners
+in the Work, of the exhaustion of those rights or of other applicable
+limitations thereto.
+
+
+5. Obligations of the Licensee
+
+The grant of the rights mentioned above is subject to some restrictions and
+obligations imposed on the Licensee. Those obligations are the following:
+
+Attribution right: The Licensee shall keep intact all copyright, patent or
+trademarks notices and all notices that refer to the Licence and to the
+disclaimer of warranties. The Licensee must include a copy of such notices
+and a copy of the Licence with every copy of the Work he/she distributes or
+communicates. The Licensee must cause any Derivative Work to carry prominent
+notices stating that the Work has been modified and the date of modification.
+
+Copyleft clause: If the Licensee distributes or communicates copies of the
+Original Works or Derivative Works, this Distribution or Communication will
+be done under the terms of this Licence or of a later version of this Licence
+unless the Original Work is expressly distributed only under this version of
+the Licence — for example by communicating 'EUPL v. 1.2 only'. The Licensee
+(becoming Licensor) cannot offer or impose any additional terms or conditions
+on the Work or Derivative Work that alter or restrict the terms of the
+Licence.
+
+Compatibility clause: If the Licensee Distributes or Communicates Derivative
+Works or copies thereof based upon both the Work and another work licensed
+under a Compatible Licence, this Distribution or Communication can be done
+under the terms of this Compatible Licence. For the sake of this clause,
+'Compatible Licence' refers to the licences listed in the appendix attached
+to this Licence. Should the Licensee's obligations under the Compatible
+Licence conflict with his/her obligations under this Licence, the obligations
+of the Compatible Licence shall prevail.
+
+Provision of Source Code: When distributing or communicating copies of the
+Work, the Licensee will provide a machine-readable copy of the Source Code or
+indicate a repository where this Source will be easily and freely available
+for as long as the Licensee continues to distribute or communicate the Work.
+
+Legal Protection: This Licence does not grant permission to use the trade
+names, trademarks, service marks, or names of the Licensor, except as
+required for reasonable and customary use in describing the origin of the
+Work and reproducing the content of the copyright notice.
+
+
+6. Chain of Authorship
+
+The original Licensor warrants that the copyright in the Original Work
+granted hereunder is owned by him/her or licensed to him/her and that he/she
+has the power and authority to grant the Licence.
+
+Each Contributor warrants that the copyright in the modifications he/she
+brings to the Work are owned by him/her or licensed to him/her and that
+he/she has the power and authority to grant the Licence.
+
+Each time You accept the Licence, the original Licensor and subsequent
+Contributors grant You a licence to their contributions to the Work, under
+the terms of this Licence.
+
+
+7. Disclaimer of Warranty
+
+The Work is a work in progress, which is continuously improved by numerous
+Contributors. It is not a finished work and may therefore contain defects or
+'bugs' inherent to this type of development.
+
+For the above reason, the Work is provided under the Licence on an 'as is'
+basis and without warranties of any kind concerning the Work, including
+without limitation merchantability, fitness for a particular purpose, absence
+of defects or errors, accuracy, non-infringement of intellectual property
+rights other than copyright as stated in Article 6 of this Licence.
+
+This disclaimer of warranty is an essential part of the Licence and a
+condition for the grant of any rights to the Work.
+
+
+8. Disclaimer of Liability
+
+Except in the cases of wilful misconduct or damages directly caused to
+natural persons, the Licensor will in no event be liable for any direct or
+indirect, material or moral, damages of any kind, arising out of the Licence
+or of the use of the Work, including without limitation, damages for loss of
+goodwill, work stoppage, computer failure or malfunction, loss of data or any
+commercial damage, even if the Licensor has been advised of the possibility
+of such damage. However, the Licensor will be liable under statutory product
+liability laws as far such laws apply to the Work.
+
+
+9. Additional agreements
+
+While distributing the Work, You may choose to conclude an additional
+agreement, defining obligations or services consistent with this Licence.
+However, if accepting obligations, You may act only on your own behalf and on
+your sole responsibility, not on behalf of the original Licensor or any other
+Contributor, and only if You agree to indemnify, defend, and hold each
+Contributor harmless for any liability incurred by, or claims asserted
+against such Contributor by the fact You have accepted any warranty or
+additional liability.
+
+
+10. Acceptance of the Licence
+
+The provisions of this Licence can be accepted by clicking on an icon 'I
+agree' placed under the bottom of a window displaying the text of this
+Licence or by affirming consent in any other similar way, in accordance with
+the rules of applicable law. Clicking on that icon indicates your clear and
+irrevocable acceptance of this Licence and all of its terms and conditions.
+
+Similarly, you irrevocably accept this Licence and all of its terms and
+conditions by exercising any rights granted to You by Article 2 of this
+Licence, such as the use of the Work, the creation by You of a Derivative
+Work or the Distribution or Communication by You of the Work or copies
+thereof.
+
+
+11. Information to the public
+
+In case of any Distribution or Communication of the Work by means of
+electronic communication by You (for example, by offering to download the
+Work from a remote location) the distribution channel or media (for example,
+a website) must at least provide to the public the information requested by
+the applicable law regarding the Licensor, the Licence and the way it may be
+accessible, concluded, stored and reproduced by the Licensee.
+
+
+12. Termination of the Licence
+
+The Licence and the rights granted hereunder will terminate automatically
+upon any breach by the Licensee of the terms of the Licence.
+
+Such a termination will not terminate the licences of any person who has
+received the Work from the Licensee under the Licence, provided such persons
+remain in full compliance with the Licence.
+
+
+13. Miscellaneous
+
+Without prejudice of Article 9 above, the Licence represents the complete
+agreement between the Parties as to the Work.
+
+If any provision of the Licence is invalid or unenforceable under applicable
+law, this will not affect the validity or enforceability of the Licence as a
+whole. Such provision will be construed or reformed so as necessary to make
+it valid and enforceable.
+
+The European Commission may publish other linguistic versions or new versions
+of this Licence or updated versions of the Appendix, so far this is required
+and reasonable, without reducing the scope of the rights granted by the
+Licence. New versions of the Licence will be published with a unique version
+number.
+
+All linguistic versions of this Licence, approved by the European Commission,
+have identical value. Parties can take advantage of the linguistic version of
+their choice.
+
+
+14. Jurisdiction
+
+Without prejudice to specific agreement between parties,
+
+- any litigation resulting from the interpretation of this License, arising
+  between the European Union institutions, bodies, offices or agencies, as a
+  Licensor, and any Licensee, will be subject to the jurisdiction of the
+  Court of Justice of the European Union, as laid down in article 272 of the
+  Treaty on the Functioning of the European Union,
+
+- any litigation arising between other parties and resulting from the
+  interpretation of this License, will be subject to the exclusive
+  jurisdiction of the competent court where the Licensor resides or conducts
+  its primary business.
+
+
+15. Applicable Law
+
+Without prejudice to specific agreement between parties,
+
+- this Licence shall be governed by the law of the European Union Member
+  State where the Licensor has his seat, resides or has his registered
+  office,
+
+- this licence shall be governed by Belgian law if the Licensor has no seat,
+  residence or registered office inside a European Union Member State.
+
+
+                                  Appendix
+
+
+'Compatible Licences' according to Article 5 EUPL are:
+
+- GNU General Public License (GPL) v. 2, v. 3
+- GNU Affero General Public License (AGPL) v. 3
+- Open Software License (OSL) v. 2.1, v. 3.0
+- Eclipse Public License (EPL) v. 1.0
+- CeCILL v. 2.0, v. 2.1
+- Mozilla Public Licence (MPL) v. 2
+- GNU Lesser General Public Licence (LGPL) v. 2.1, v. 3
+- Creative Commons Attribution-ShareAlike v. 3.0 Unported (CC BY-SA 3.0) for
+  works other than software
+- European Union Public Licence (EUPL) v. 1.1, v. 1.2
+- Québec Free and Open-Source Licence — Reciprocity (LiLiQ-R) or Strong
+  Reciprocity (LiLiQ-R+).
+
+The European Commission may update this Appendix to later versions of the
+above licences without producing a new version of the EUPL, as long as they
+provide the rights granted in Article 2 of this Licence and protect the
+covered Source Code from exclusive appropriation.
+
+All other changes or additions to this Appendix require the production of a
+new EUPL version.

src/VERSION

@@ -1 +1 @@
-0.2
+0.1.1

src/testium/api/runtime_plot.py

@@ -1,5 +1,6 @@
 import sys
 import os
+import queue
 import multiprocessing as mp
 from threading import Timer
 from time import sleep, monotonic
@@ -367,7 +368,7 @@ class RuntimePlot:
             self.msg_queue_in.get()
         self.msg_queue_out.put({"command": "last_values"})
         try:
-            res = self.msg_queue_in.get(timeout=1)
+            res = self.msg_queue_in.get(timeout=5)
-        except:
+        except queue.Empty:
             raise ETUMRuntimeError(f"Impossible to retrieve the last values of the \"{self.name}\" plot")
         return res

src/testium/interpreter/test_items/dialog_env.py

@@ -10,6 +10,8 @@ import os
 def setup():
     """Configure the Qt environment for dialog subprocess usage."""
     if sys.platform.startswith('linux'):
-        # On Linux/Wayland, force X11 (via XWayland) to avoid crashes
+        if os.environ.get('DISPLAY'):
-        # when Qt is initialized inside a multiprocessing subprocess.
+            # X11 available: force xcb to avoid crashes in multiprocessing subprocesses.
-        os.environ['QT_QPA_PLATFORM'] = 'xcb'
+            os.environ['QT_QPA_PLATFORM'] = 'xcb'
+        elif os.environ.get('WAYLAND_DISPLAY'):
+            os.environ['QT_QPA_PLATFORM'] = 'wayland'

src/testium/interpreter/test_items/test_item_run.py

@@ -13,6 +13,32 @@ from interpreter.utils.constants import TestItemType as cst
 from runtime.tum_except import ETUMSyntaxError, ETUMRuntimeError, item_load_context
 
 
+def _testium_launch_cmd():
+    """Command prefix to launch a fresh testium instance, runtime-aware.
+
+    AppImage / Flatpak / PyInstaller / wheel / source all need a different
+    entry point than just the path to __main__.py (which may be a .py inside
+    a read-only bundle, or unreachable from the sub-instance's cwd).
+    """
+    # AppImage: the env var holds the path to the .AppImage file itself.
+    appimage = os.environ.get("APPIMAGE")
+    if appimage:
+        return [appimage]
+    # Flatpak: re-launch via the Flatpak app id.
+    if os.path.isfile("/.flatpak-info"):
+        return ["flatpak", "run", "org.testium.Testium"]
+    # PyInstaller frozen exe: sys.executable is the binary itself.
+    if getattr(sys, "frozen", False):
+        return [sys.executable]
+    # Source / wheel: re-use the same Python with the same entry point that
+    # launched this instance, made absolute so cwd changes in the sub-instance
+    # don't break the lookup. argv[0] is either:
+    #  - the package directory (source: `python3 src/testium ...`)
+    #  - the console_scripts wrapper (wheel: `/usr/bin/testium`)
+    # Both are runnable as `python <argv0>`.
+    return [sys.executable, os.path.abspath(sys.argv[0])]
+
+
 def nowInBetween(start, end):
     """
     Check wether current time is within boundaries
@@ -33,8 +59,6 @@ class TestItemRun(TestItem):
         with item_load_context(self.cmd(), self.name(), self.seqFilename()):
             self.tum_file = self._prms.getParam('tum', required=True)
             self.param_file = self._prms.getParam('param_file', default='')
-            self.python_bin = self._prms.getParam('python_bin', default='')
-            self.testium_path = self._prms.getParam('testium_path', default='')
             self.log_path = self._prms.getParam('log_file', default='')
             self.report_path = self._prms.getParam('report_file', default='')
             self.start_time = self._prms.getParam('start_time')
@@ -52,18 +76,9 @@ class TestItemRun(TestItem):
                     '"{}" file could not be found'.format(file_path))
             self.tum_file = file_path
             pf = self._prms.expanse(self.param_file)
-            pp = self._prms.expanse(self.python_bin)
-            sp = self._prms.expanse(self.testium_path)
             lp = self._prms.expanse(self.log_path)
             rp = self._prms.expanse(self.report_path)
-            cmd = []
+            cmd = _testium_launch_cmd()
-            if sp == '':
-                sp = sys.argv[0]
-            if pp != '':
-                cmd.append(pp)
-            elif not os.path.isfile(sp) or not os.access(sp, os.X_OK):
-                cmd.append(sys.executable)
-            cmd.append(sp)
             if tm.text_mode():
                 cmd.append("-b")
             else:

src/testium/interpreter/utils/bins.py

@@ -17,7 +17,7 @@ Public API
 ``reset()``             : clear the cache (mostly useful for tests)
 """
 
-import shutil
+import os
 import subprocess
 
 import api.testium as tm
@@ -30,10 +30,126 @@ from runtime.tum_except import ETUMRuntimeError
 _PYTHON_CANDIDATES = ["python3", "python"]
 _LUA_CANDIDATES = ["lua", "lua5.5", "lua5.4", "lua5.3", "lua5.2", "lua5.1"]
 
+# When running inside a Flatpak, --filesystem=host-os mounts the host at
+# /run/host (read-only). Binaries and libraries from the host are not on the
+# sandbox PATH/LD_LIBRARY_PATH, so we probe and inject them explicitly.
+_FLATPAK_HOST_DIRS = [
+    "/run/host/usr/local/bin",
+    "/run/host/usr/bin",
+    "/run/host/bin",
+]
+_FLATPAK_HOST_LIB_DIRS = [
+    "/run/host/usr/lib",
+    "/run/host/usr/lib64",
+    "/run/host/usr/local/lib",
+]
+
+# Inside an AppImage, AppRun prepends $APPDIR/usr/bin to PATH and exports a
+# bundle-local PYTHONHOME / PYTHONPATH / LD_LIBRARY_PATH. We want py_func and
+# lua_func to run under the *host* interpreter (not the bundled one), so we
+# probe standard host bin dirs directly and scrub APPDIR-prefixed entries from
+# the env passed to host subprocesses.
+_APPIMAGE_HOST_DIRS = [
+    "/usr/local/bin",
+    "/usr/bin",
+    "/bin",
+]
+
+
+def _in_flatpak():
+    return os.path.isfile("/.flatpak-info")
+
+
+def _in_appimage():
+    return "APPIMAGE" in os.environ
+
+
+def apply_host_lua_paths(env):
+    """Prepend host Lua module dirs to LUA_PATH / LUA_CPATH (Flatpak only).
+
+    Must be called after user-defined lua_env overrides are applied, so host
+    paths are always first regardless of user config. User-defined paths remain
+    in the variable but after the host ones.
+    """
+    if not _in_flatpak():
+        return
+    _LUA_VERSIONS = ["5.5", "5.4", "5.3", "5.2", "5.1"]
+    _HOST = "/run/host/usr"
+    cpath_dirs, lpath_dirs = [], []
+    for v in _LUA_VERSIONS:
+        for base in [f"{_HOST}/lib/lua/{v}",
+                     f"{_HOST}/lib64/lua/{v}",
+                     f"{_HOST}/lib/x86_64-linux-gnu/lua/{v}"]:
+            cpath_dirs.append(f"{base}/?.so")
+        lpath_dirs.append(f"{_HOST}/share/lua/{v}/?.lua")
+        lpath_dirs.append(f"{_HOST}/share/lua/{v}/?/init.lua")
+    sep = ";"
+    host_cpath = sep.join(cpath_dirs)
+    host_lpath = sep.join(lpath_dirs)
+    # ;; keeps Lua's compiled-in defaults at the end as last resort
+    env["LUA_CPATH"] = host_cpath + sep + env.get("LUA_CPATH", ";;")
+    env["LUA_PATH"]  = host_lpath + sep + env.get("LUA_PATH",  ";;")
+
+
+def apply_host_libs(env):
+    """Prepare *env* for launching a host binary from inside our bundle.
+
+    - Flatpak: prepend host library dirs to LD_LIBRARY_PATH so the dynamic
+      linker can find host .so files mounted under /run/host.
+    - AppImage: strip $APPDIR-prefixed entries from LD_LIBRARY_PATH and
+      PYTHONPATH and drop PYTHONHOME, so the host interpreter doesn't try
+      to load the bundled (incompatible) Python lib/site-packages.
+    - Otherwise: no-op.
+    """
+    if _in_flatpak():
+        dirs = ":".join(d for d in _FLATPAK_HOST_LIB_DIRS if os.path.isdir(d))
+        if dirs:
+            existing = env.get("LD_LIBRARY_PATH", "")
+            env["LD_LIBRARY_PATH"] = dirs + (":" + existing if existing else "")
+        return
+    if _in_appimage():
+        appdir = os.environ.get("APPDIR", "")
+        if appdir:
+            for var, sep in (("LD_LIBRARY_PATH", ":"),
+                             ("PYTHONPATH", os.pathsep),
+                             ("PATH", os.pathsep)):
+                cur = env.get(var, "")
+                if not cur:
+                    continue
+                cleaned = sep.join(
+                    p for p in cur.split(sep)
+                    if p and not p.startswith(appdir)
+                )
+                if cleaned:
+                    env[var] = cleaned
+                else:
+                    env.pop(var, None)
+        env.pop("PYTHONHOME", None)
+
 
 def _which(name):
-    func = sys_app_path_win if tm.OS() == "Windows" else sys_app_path_lin
+    if tm.OS() == "Windows":
-    return func(name)
+        return sys_app_path_win(name)
+    if _in_flatpak():
+        for d in _FLATPAK_HOST_DIRS:
+            p = os.path.join(d, name)
+            if os.path.isfile(p) and os.access(p, os.X_OK):
+                return p
+        return ""
+    if _in_appimage():
+        for d in _APPIMAGE_HOST_DIRS:
+            p = os.path.join(d, name)
+            if os.path.isfile(p) and os.access(p, os.X_OK):
+                return p
+        return ""
+    return sys_app_path_lin(name)
+
+
+def _probe_env():
+    """Subprocess env for probing host binaries (adds host libs in Flatpak)."""
+    env = os.environ.copy()
+    apply_host_libs(env)
+    return env
 
 
 def _python_version(path):
@@ -41,7 +157,7 @@ def _python_version(path):
     try:
         r = subprocess.run(
             cmd, capture_output=True, text=True,
-            encoding=tm.sys_encoding(), timeout=10,
+            encoding=tm.sys_encoding(), timeout=10, env=_probe_env(),
         )
     except (FileNotFoundError, PermissionError, subprocess.TimeoutExpired):
         return None
@@ -60,6 +176,7 @@ def _lua_version(path):
     try:
         r = subprocess.run(
             [path, "-v"], capture_output=True, text=True, timeout=10,
+            env=_probe_env(),
         )
     except (FileNotFoundError, PermissionError, subprocess.TimeoutExpired):
         return None
@@ -97,8 +214,16 @@ def _resolve(name):
 
     path = ""
     if override:
-        if shutil.which(override) and validator(override):
+        # Absolute path: accept as-is (user knows exactly what they want).
-            path = override
+        # Bare name: resolve via _which() so the override stays host-only in
+        # Flatpak/AppImage instead of silently picking the bundled interpreter.
+        if os.path.isabs(override):
+            resolved = override if (os.path.isfile(override)
+                                    and os.access(override, os.X_OK)) else ""
+        else:
+            resolved = _which(override)
+        if resolved and validator(resolved):
+            path = resolved
         else:
             tm.print_warn(
                 f"Configured {display} interpreter '{override}' is not usable; "

src/testium/interpreter/utils/lua_process.py

@@ -60,6 +60,7 @@ class LuaProcessBase:
 
         lua_env = tm.gd("lua_env", {})
         env = os.environ.copy()
+        bins.apply_host_libs(env)
         if not isinstance(lua_env, dict):
             raise ETUMRuntimeError(f"The 'lua_env' global value should be a dictionary. But it is '{lua_env}'.")
 
@@ -70,6 +71,7 @@ class LuaProcessBase:
                     env[k] = e
                 else:
                     env[k] = e + ";" + env.get(k, "")
+        bins.apply_host_lua_paths(env)
 
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         sock.bind(("localhost", 0))

src/testium/interpreter/utils/py_process.py

@@ -42,6 +42,10 @@ class PyProcessBase:
             raise ETUMRuntimeError(f"The 'py_env' global value should be a dictionary. But it is '{py_env}'.")
 
         env = os.environ.copy()
+        bins.apply_host_libs(env)
+        # PYTHONUSERBASE is set by the Flatpak runtime to isolate sandbox
+        # user packages; remove it so the host Python finds ~/.local packages.
+        env.pop("PYTHONUSERBASE", None)
         for k, v in self.CUST_ENV.items():
             e = py_env.get(k, "")
             if e != "":

src/testium/interpreter/utils/version.py

@@ -31,10 +31,15 @@ def get_version(path :str)-> str:
         return "Warning git not supported in your settings, version of {} unknown".format(path)
 
 def get_testium_version():
+    # Flatpak bundle
+    if os.path.isfile('/.flatpak-info'):
+        ver = os.environ.get('TESTIUM_VERSION', '').strip()
+        return (ver if ver else 'unknown') + " (flatpak release)"
+
     # AppImage
     if 'APPIMAGE' in os.environ:
-        ver = os.getenv('SEQUENCER_REV', 'unknown')
+        ver = os.environ.get('TESTIUM_VERSION', '').strip()
-        return ver + " (binary release)"
+        return (ver if ver else 'unknown') + " (binary release)"
 
     # PyInstaller frozen exe
     if getattr(sys, 'frozen', False):

src/testium/py_func/__main__.py

@@ -8,14 +8,18 @@ def exception_handler(typ_exc, value, trbk):
     print(f"Critical failure : '{value}'.")
     tb = traceback.format_exception(typ_exc, value, trbk)
     print("".join(tb))
+    print(f"  python    : {sys.executable}")
+    print(f"  sys.path  : {sys.path}")
 
 sys.excepthook = exception_handler
 
-p = Path(__file__)
+# Make the parent directory of py_func/ (= the testium package dir, which also
-p = p.parent / ".."
+# contains runtime/, lua_func/, …) the first entry on sys.path so `from py_func
-p = p.resolve()
+# import main` and `from runtime…` resolve regardless of cwd or how this script
-
+# was invoked. str() because some importers don't play well with PathLike entries.
-sys.path.append(p)
+_pkg_parent = str((Path(__file__).resolve().parent / "..").resolve())
+if _pkg_parent not in sys.path:
+    sys.path.insert(0, _pkg_parent)
 
 from py_func import main