From 20f9398bd4700c965c031d19a899132174805315 Mon Sep 17 00:00:00 2001
From: william <you@example.com>
Date: Tue, 15 Sep 2026 19:39:39 +0200
Subject: [PATCH 1/4] Phase 4 (CI) : securise le job deploy (token registre,
 cle SSH)

- docker login sur le serveur distant : passe le token via
  --password-stdin (echo | docker login ...) plutot qu'en argument -p,
  meme methode que build-and-push - un -p en argument reste visible via
  ps sur le serveur tant que le process tourne.
- Nouvelle etape "Nettoyage de la cle SSH" (if: always()) : supprime
  ~/.ssh/deploy_key en fin de job, meme si une etape precedente a
  echoue. rm -f (jamais rm nu) : sortie 0 que le fichier ou meme le
  dossier ~/.ssh parent soit deja absent, verifie empiriquement - ne
  peut jamais faire echouer ce nettoyage ni masquer un echec anterieur.
  Le runner semble deja jetable (docker volume rm observe dans les logs
  d'un autre job de ce meme workflow), mais jamais verifie directement
  pour deploy (jamais execute sur dev, reserve a main) - nettoyage
  explicite plutot qu'une inference par analogie pour une cle privee.

djLint (H021, styles inline) volontairement saute pour ce commit - meme
backlog assume que les commits Phase 3/4 precedents, aucun rapport avec
ce changement.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 .gitea/workflows/deploy.yml | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/.gitea/workflows/deploy.yml b/.gitea/workflows/deploy.yml
index 642f4120..1e7fec1c 100644
--- a/.gitea/workflows/deploy.yml
+++ b/.gitea/workflows/deploy.yml
@@ -205,8 +205,19 @@ jobs:
             cd "${{ secrets.DEPLOY_PATH }}"
             echo "REGISTRY_IMAGE=${{ secrets.REGISTRY_IMAGE }}" > .env
             echo "IMAGE_TAG=${{ gitea.sha }}" >> .env
-            docker login "${{ secrets.REGISTRY_HOST }}" -u "${{ secrets.REGISTRY_USER }}" -p "${{ secrets.REGISTRY_TOKEN }}"
+            echo "${{ secrets.REGISTRY_TOKEN }}" | docker login "${{ secrets.REGISTRY_HOST }}" -u "${{ secrets.REGISTRY_USER }}" --password-stdin
             docker compose -f docker-compose.prod.yml pull
             docker compose -f docker-compose.prod.yml up -d
             docker image prune -f
           '
+
+      - name: Nettoyage de la cle SSH
+        # if: always() - meme si les etapes precedentes ont echoue, la cle
+        # privee posee ci-dessus (~/.ssh/deploy_key) ne doit jamais rester
+        # sur le disque du job. Le runner semble deja jetable (voir
+        # "docker volume rm .../JOB-<id>-..." dans les logs des autres
+        # jobs de ce meme workflow), mais jamais verifie directement pour
+        # CE job (jamais execute sur dev, reserve a main) - ne pas se fier
+        # uniquement a une inference par analogie pour une cle privee.
+        if: always()
+        run: rm -f ~/.ssh/deploy_key
-- 
2.54.0


From 55e81c0fbb9e99323a426380a0b87d2d8d3cc5b1 Mon Sep 17 00:00:00 2001
From: william <you@example.com>
Date: Wed, 16 Sep 2026 12:41:02 +0200
Subject: [PATCH 2/4] Ajoute CODE_QUALITY.md et corrige S7632 a la racine
 (helper assert_not_none)

- Nouveau db/assert_not_none.py : centralise l'unique suppression
  Bandit/Ruff (# nosec B101 / # noqa: S101) de narrowing de type dans
  tout le moteur. Remplace 11 sites disperses (ai/chat.py, ai/tools.py,
  routes/scenes/scene_object_{add,collision,geometry,personnage_data,
  quiz_config}.py, screens/payload/full_game_payload.py,
  scripts/build_demo_dialogues.py) qui repetaient chacun le meme
  commentaire empile - Sonar (python:S7632) ne parse pas deux
  commentaires # sur une ligne, meme si Ruff et Bandit les acceptent
  chacun tres bien (contrainte structurelle documentee dans
  CODE_QUALITY.md : chaque outil exige son propre mot-cle immediatement
  apres un #, aucun format a un seul # ne peut satisfaire les deux a la
  fois). Les 6 sites # nosec B608 (SQL dynamique) restent inchanges,
  nature differente, hors perimetre de ce refactor.
  Verifie : mypy --strict propre (389 fichiers), ruff/bandit/import-linter
  clean, suite complete verte (591 tests), scan SonarQube local relance
  confirmant S7632 a 7 (1 seul site restant dans le helper lui-meme + les
  6 B608), 0 bug (une regression S8371 trouvee et corrigee en route).

- 4 sites |safe repositionnes sur leur ligne exacte (scene_edit.html,
  register_2fa.html, onboarding_new.html, play.html) - le marqueur
  NOSONAR etait sur la ligne precedente par erreur (meme piege que celui
  documente pour S8371 ci-dessus). Confirme par scan que meme corrige,
  l'analyseur Web de Sonar ne supporte aucune syntaxe de suppression
  inline testee pour la regle Web:S5247 - documente comme limitation
  technique connue dans CODE_QUALITY.md plutot que force.

- CODE_QUALITY.md (nouveau) : reference complete du dispositif qualite -
  vue d'ensemble par outil, configuration de chacun, commandes de lancement
  local, procedure de justification d'une exception (avec le format exact
  attendu par Bandit/Ruff/Sonar, verifie empiriquement), table des 10
  exceptions documentees, backlog (djLint H021, code smells Sonar).

djLint (H021, styles inline) volontairement saute pour ce commit - meme
backlog assume que les commits precedents, aucun rapport avec ce changement.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 CODE_QUALITY.md                               | 143 ++++++++++++++++++
 ai/chat.py                                    |   4 +-
 ai/tools.py                                   |   4 +-
 db/__init__.py                                |   2 +
 db/assert_not_none.py                         |  15 ++
 routes/scenes/scene_object_add.py             |  13 +-
 routes/scenes/scene_object_collision.py       |   5 +-
 routes/scenes/scene_object_geometry.py        |   5 +-
 routes/scenes/scene_object_personnage_data.py |   5 +-
 routes/scenes/scene_object_quiz_config.py     |   5 +-
 screens/payload/full_game_payload.py          |   4 +-
 scripts/build_demo_dialogues.py               |   6 +-
 templates/auth/register_2fa.html              |   3 +-
 templates/onboarding/onboarding_new.html      |   3 +-
 templates/play.html                           |   2 +-
 templates/scene_edit.html                     |   3 +-
 16 files changed, 187 insertions(+), 35 deletions(-)
 create mode 100644 CODE_QUALITY.md
 create mode 100644 db/assert_not_none.py

diff --git a/CODE_QUALITY.md b/CODE_QUALITY.md
new file mode 100644
index 00000000..e4db0e35
--- /dev/null
+++ b/CODE_QUALITY.md
@@ -0,0 +1,143 @@
+# Qualité de code — Forge Engine
+
+Référence de fonctionnement du dispositif qualité mis en place (Phases 1
+à 4). Pour le compte-rendu chronologique de ce qui a été fait/trouvé/
+décidé pendant la mise en place, voir `docs/SESSION_RECAP.md` — ce
+fichier-ci documente uniquement **l'état actuel** et **comment
+l'utiliser au quotidien**.
+
+Règle de base, non négociable : **aucune règle de lint/typage n'est
+désactivée globalement dans un fichier de config sans validation
+explicite.** Une exception ponctuelle est toujours une ligne de code
+(`# noqa`, `# nosec`, `// NOSONAR`) avec une raison précise, jamais un
+ignore de fichier entier ou de règle globale — voir section 4.
+
+## 1. Vue d'ensemble
+
+| Outil | Vérifie | Portée | Obligatoire / Avertissement |
+|---|---|---|---|
+| **Ruff** (lint) | Erreurs Python, imports inutilisés, style | `*.py` | Obligatoire (bloquant CI + pre-commit) |
+| **Ruff** (format) | Formatage Python | `*.py` | Obligatoire |
+| **Mypy** `--strict` | Typage statique Python | `*.py` | Obligatoire |
+| **Bandit** | Sécurité Python (injections, primitives faibles) | `ai`, `auth`, `core`, `db`, `filters`, `publish`, `routes`, `screens`, `scripts`, `app.py`, `build_css.py` | Obligatoire |
+| **Vulture** | Code mort Python | mêmes dossiers que Bandit | Obligatoire |
+| **import-linter** | Contrat de couches applicatives | tout le code Python | Obligatoire |
+| **ESLint** (`airbnb-base`) | Lint JavaScript | `static/js/**/*.js` | Obligatoire |
+| **Stylelint** (`stylelint-config-standard`) | Lint CSS | `styles/**/*.css` | Obligatoire |
+| **djLint** | Lint des templates Jinja | `templates/**/*.html` | **Avertissement** — H021 (styles inline) en backlog assumé, voir section 6 |
+| **SonarQube** (local + CI) | Bugs/vulnérabilités/code smells/hotspots agrégés | tout le dépôt | **Avertissement** — non-bloquant en CI pour l'instant, voir section 3 |
+
+## 2. Configuration de chaque outil
+
+### Ruff (`pyproject.toml`, `[tool.ruff]`)
+- `line-length = 120`, `target-version = "py313"`.
+- Règles activées : `F` (pyflakes), `E`/`W` (pycodestyle), `B` (bugbear), `C4` (comprehensions), `SIM` (simplification), `S` (bandit-équivalent Ruff), `I` (imports).
+- `per-file-ignores` : `S101`/`S106` désactivées pour `tests/` uniquement (assert et mots de passe en dur sont la norme dans les tests, jamais en dehors).
+- Exclusions : `projects/`, `user_assets/`, `data/`, `Bug/`, `regles/` (données runtime, jamais du code).
+
+### Mypy (`pyproject.toml`, `[tool.mypy]`)
+- `strict = true`, `python_version = "3.13"`.
+- `explicit_package_bases = true` + `mypy_path = "."` : nécessaire car `tests/` n'a pas de `__init__.py` — sans ça mypy refuse de démarrer ("Source file found twice under different module names"). **Ce n'est pas un assouplissement de `strict`**, juste la résolution des chemins de module.
+- Mêmes exclusions que Ruff.
+
+### Bandit (`pyproject.toml`, `[tool.bandit]`)
+- `exclude_dirs` : `projects`, `user_assets`, `data`, `Bug`, `regles`, `tests` (les tests contiennent des mots de passe/tokens de test en dur, jamais un vrai risque).
+- Portée explicite (`-r ai auth core db filters publish routes screens scripts app.py build_css.py`) plutôt que tout le dépôt.
+
+### Vulture (`pyproject.toml`, `[tool.vulture]`)
+- `min_confidence = 80`, `paths` = mêmes dossiers que Bandit + `vulture_whitelist.py`.
+- `exclude = ["*/tests/*"]`.
+- Faux positifs structurels (routes Flask enregistrées par décorateur, hooks appelés par convention de nom) : whitelist dédiée dans `vulture_whitelist.py`, **jamais** un `min_confidence` abaissé globalement.
+
+### import-linter (`pyproject.toml`, `[tool.importlinter]`)
+- Un seul contrat de type `layers`, du haut vers le bas : `routes` → `ai | publish | core` → `screens` → `auth | filters` → `db`.
+- Une couche ne peut importer qu'une couche strictement en dessous d'elle, jamais au-dessus, jamais une couche sœur du même niveau.
+- `app.py` (point d'entrée, pas un paquet) reste hors contrat — c'est lui qui importe `routes`/`core`, jamais l'inverse.
+
+### ESLint (`.eslintrc.json`)
+- Base `airbnb-base` + plugin `unused-imports`.
+- `max-len` porté à 120 (aligné sur Ruff) au lieu du 80 par défaut d'Airbnb.
+- Plusieurs règles Airbnb désactivées **après vérification individuelle que le code existant les respecte déjà différemment** (voir section 5 pour le détail et le raisonnement de chacune) : `no-param-reassign`, `no-use-before-define` (assoupli pour les fonctions, gardé strict pour variables/classes), `func-names`, `no-underscore-dangle`, `no-console`, `no-plusplus`, `no-continue`, `no-bitwise`, `guard-for-in`, `no-restricted-syntax`, `prefer-destructuring`, `consistent-return`, `no-return-assign`, `no-nested-ternary`, `no-void`, `implicit-arrow-linebreak`, `no-unused-expressions`, `no-useless-concat`.
+- `unused-imports/no-unused-vars` avec une liste blanche (`varsIgnorePattern`) d'environ 95 noms : fonctions invoquées uniquement depuis des attributs `onclick`/`onchange` inline dans les templates Jinja, invisibles pour l'analyse statique d'ESLint.
+- Bloc `globals` documentant les variables cross-fichiers volontaires (ex. `gameData`, `screensData` — voir section 5).
+
+### Stylelint (`.stylelintrc.json`)
+- Base `stylelint-config-standard`.
+- `selector-class-pattern`/`selector-id-pattern` désactivées : le projet utilise du camelCase pour ses classes/id CSS depuis le début (`.canvasElement`, `#scormProgress`...) — imposer le kebab-case du preset aurait demandé de renommer des milliers de sélecteurs et leurs usages JS/HTML pour un gain nul.
+- `no-descending-specificity` désactivée : le CSS existant est organisé par composant/fonctionnalité, pas par ordre strict de spécificité.
+- `ignoreFiles` : `static/vendor/**`, `static/style.css` (bundle généré, contient du Bulma vendored).
+
+### djLint (`pyproject.toml`, `[tool.djlint]`)
+- `profile = "jinja"`, `max_line_length = 160`, `indent = 2`.
+- H021 (styles inline) : **backlog assumé, pas une exception corrigée** — voir section 6, ne pas confondre avec les vraies exceptions de la section 5.
+
+### SonarQube
+- **Local (développement continu)** : Docker Community Build + PostgreSQL (jamais la base H2 embarquée), tourne en permanence sur cette machine via `~/sonarqube-stack/docker-compose.yml` (WSL2/Ubuntu). Dashboard : **http://localhost:9000** — identifiants personnels, jamais consignés ici.
+- **CI (`sonar.forgebase.fr`)** : instance séparée, self-hébergée, scan à chaque push via `.gitea/workflows/deploy.yml` (job `sonarqube`), **non-bloquant** (`continue-on-error: true`) le temps que le rapport soit entièrement trié.
+
+## 3. Lancer les checks en local
+
+```bash
+# Un outil a la fois (memes commandes que .pre-commit-config.yaml)
+ruff check .
+ruff format --check .
+mypy .
+vulture
+bandit -c pyproject.toml -r ai auth core db filters publish routes screens scripts app.py build_css.py
+lint-imports
+djlint templates
+npx eslint "static/js/**/*.js"
+npx stylelint "styles/**/*.css"
+
+# Tout d'un coup (ce que fait un commit)
+pre-commit run --all-files
+
+# Suite de tests
+python -m pytest tests/ -q
+node --test static/js/play/__tests__/*.test.js static/js/scenes/__tests__/*.test.js
+
+# Scan SonarQube local (rapport seul - jamais de correction automatique
+# a partir de son seul resultat sans triage prealable, voir section 4)
+# Necessite le stack Docker local demarre (voir section 2) et un token
+# genere sur http://localhost:9000 (Mon compte > Security > Generate Token).
+docker run --rm --network sonarqube-stack_default \
+  -v <chemin-absolu-du-repo>:/usr/src \
+  sonarsource/sonar-scanner-cli \
+  -Dsonar.host.url=http://sonarqube:9000 \
+  -Dsonar.token=<votre-token>
+```
+
+## 4. Procédure de justification d'une exception
+
+1. **Jamais de correction mécanique sans comprendre la cause.** Avant de corriger un finding, déterminer s'il s'agit d'un vrai problème ou d'un faux positif dû au contexte du projet (fixture pytest, dispatch dynamique JS/Jinja, whitelist codée en dur, architecture volontaire).
+2. **Une exception ponctuelle, jamais globale.** Le commentaire de suppression va **sur la ligne exacte** signalée par l'outil — pas la ligne au-dessus, pas la ligne en dessous (piège vécu à plusieurs reprises cette session : un commentaire mal placé ne supprime rien du tout, silencieusement).
+3. **La raison est précise, jamais vague.** "Faux positif" seul ne suffit pas — expliquer *pourquoi* (ex. "table_name vient de slugify()+prefixe obj_, jamais d'une entrée brute").
+4. **Format attendu par outil** (vérifié empiriquement cette session, chaque outil a ses propres exigences de position du mot-clé) :
+   - Bandit : `# nosec <CODE>` — le mot `nosec` doit être immédiatement précédé d'un `#` sur la ligne.
+   - Ruff : `# noqa: <CODE>` — le mot `noqa` doit être immédiatement précédé d'un `#` sur la ligne. **Bandit et Ruff peuvent coexister sur une même ligne physique** en utilisant deux `#` distincts (`# nosec B101  # noqa: S101 - raison`) — c'est structurel, pas un choix de style : chaque outil cherche son propre mot-clé juste après un `#`, et aucun format à un seul `#` ne peut satisfaire les deux à la fois (testé empiriquement).
+   - SonarQube (Python) : `# NOSONAR <règle> - raison`, sur la ligne exacte.
+   - SonarQube (JS) : `// NOSONAR <règle> - raison`, sur la ligne exacte.
+   - SonarQube (templates Jinja/HTML, règle `Web:*`) : **aucune syntaxe trouvée qui fonctionne** malgré plusieurs tentatives (commentaire Jinja `{# #}`, commentaire JS natif dans un `<script>`, bonne position de ligne) — voir la limitation documentée en section 5 (`Web:S5247`).
+5. **Toute exception validée est répercutée ici** (section 5), avec la date/le contexte. Une exception non documentée ici n'est pas considérée comme validée.
+6. **Qui valide** : aucune exception n'est appliquée sans validation explicite de l'utilisateur — présenter le choix avec ses compromis, jamais trancher seul quand plusieurs options légitimes existent.
+
+## 5. Exceptions et faux positifs documentés
+
+| Site(s) | Outil / règle | Raison | Contexte |
+|---|---|---|---|
+| `core/flask_app.py:22` | `python:S4502` (Sonar) | CSRF géré par `core/csrf_guard.py` — garde maison globale (`@app.before_request`), testée dans `test_csrf.py`, jamais Flask-WTF. Sonar ne reconnaît pas cette implémentation custom. | Phase 3 |
+| `screens/data_actions/compute_operation.py` (×2), `static/js/play/offline/compute-operation.js` (×2), `static/js/scenes/collision-rules-editor.js` (×2), `static/js/triggers/trigger-editor.js` | `B311`/`S311`/`python:S2245`/`javascript:S2245` | Tirage aléatoire de jeu (dé, id local d'UI) — jamais un usage cryptographique. | Phase 3 |
+| `static/js/play/offline/xapi-client.js` (18 sites) + `static/js/play/offline/__tests__/xapi-client.test.js` (2 sites) | `javascript:S5332` | Identifiants du vocabulaire xAPI standard ADL (`http://adlnet.gov/expapi/...`), jamais déréférencés en réseau — simples chaînes comparées/embarquées, le `http://` fait partie du texte fixé par la spec. Le vrai endpoint réseau (`config.endpoint`) est toujours saisi par le créateur, jamais un littéral de ce fichier. | Phase 3 |
+| `publish/scorm_manifest.py` | `B406` (Bandit) | Seul fichier du dépôt qui touche du XML — uniquement en génération (`xml.sax.saxutils.escape`), jamais en parsing d'XML externe. | Phase 3 |
+| `scripts/build_demo_dialogues.py:61-63` | `python:S8371` (Sonar) | Accès direct `resp.headers["Location"]` volontaire : script d'usage unique jamais exécuté en production, un `KeyError` cru est un échec au moins aussi clair qu'un `.get()` renvoyant `None`. | Phase 3 |
+| `static/js/scenes/collision-rules-editor.js` (`leafAction.then = nextLeaf`) | `javascript:S7739` | `then` est un champ métier ("action suivante de la chaîne"), jamais une promesse — vérifié qu'aucun site d'appel ne le passe à `await`/`Promise.resolve()`. Risque latent documenté plutôt que renommage (le nom est ancré dans le schéma JSON persisté en base et côté Python). | Phase 3 |
+| `db/assert_not_none.py:14` | `B101`/`S101`/`python:S7632` | Unique `assert` de narrowing de type restant dans tout le moteur, après centralisation de 11 sites dispersés (`ai/`, `routes/scenes/`, `screens/payload/`, `scripts/`) dans ce helper unique. Voir section 4 pour l'impossibilité structurelle de satisfaire Bandit+Ruff avec un seul `#`. | Session du 16/09/2026 |
+| `db/rows/delete_row.py`, `db/rows/get_row.py`, `db/rows/list_rows.py`, `screens/animations/update_animation_clip.py`, `screens/flow/add_flow_node.py`, `screens/scenes/add_scene_object.py` | `B608`/`S608`/`python:S7632` | Noms de table/colonnes construits uniquement à partir de `slugify()`/whitelists codées en dur (`_UPDATABLE_FIELDS`, `FLOW_NODE_FIELDS`), jamais d'une entrée arbitraire — valeurs toujours paramétrées (`?`). Distinct du cas `assert_not_none` ci-dessus (nature différente : construction de SQL, pas narrowing de type) — non couvert par ce refactor. | Session du 16/09/2026 |
+| `static/js/play/bindings.js:179` (`gameData = newData`) | `javascript:S2703` | Pattern volontaire de scripts globaux (pas des modules ES) : `gameData`/`screensData` sont déclarés une fois par `let` dans le `<script>` inline de `templates/play.html`, chargé avant tous les `static/js/play/*.js` (ordre séquentiel vérifié, pas de `defer`/`async`). Réassignation légitime d'une variable déjà déclarée dans un scope global partagé — déjà documenté dans `.eslintrc.json` (`"gameData": "writable"`). | Session du 16/09/2026 |
+| 31 sites `\|safe` (`templates/scene_edit.html`, `templates/play.html`, `templates/auth/register_2fa.html`, `templates/onboarding/onboarding_new.html`, `templates/game_dashboard_simple.html`) | `Web:S5247` (Sonar) | **Faux positif confirmé sur le fond, mais non-supprimable techniquement pour l'instant.** 3 sous-groupes : (1) `rendered_html`/`qr_svg`/`description` — HTML déjà échappé côté Python (`html.escape()`) ou généré sans texte libre utilisateur ; (2) 25 sites `*_json` — `db.json_for_script()` échappe déjà `</script>` (voir Phase 3). Plusieurs syntaxes de suppression testées (commentaire Jinja `{# #}`, commentaire JS natif dans un `<script>`, bonne position de ligne) : **aucune ne fonctionne** avec l'analyseur Web de cette version de SonarQube. La résolution "Faux positif" via l'API est bloquée par le système de permissions de session. `sonar.issue.ignore.multicriteria` existe mais sans sélecteur de ligne (exclusion fichier entier uniquement) — écarté pour `scene_edit.html`/`play.html` (masquerait un futur `\|safe` réellement dangereux). Ces 31 sites restent visibles dans le rapport Sonar en l'état ; traités et compris, pas un point ouvert côté code. | Phase 3 + investigation du 16/09/2026 |
+
+## 6. Backlog qualité
+
+- **djLint H021 (49 occurrences, 6 templates)** — styles inline à remplacer par un système de modèles/classes CSS réutilisables. **Priorité immédiate** après la clôture de ce dispositif, avant ou après la Phase 4 CI selon décision à prendre le moment venu. Ce n'est **pas** une exception documentée en section 5 : c'est une dette assumée et non traitée, à corriger, pas à justifier indéfiniment.
+- **Code smells SonarQube (421 restants)** — analysés en volume (modernisation JS, complexité cognitive Python, duplication) mais pas encore triés catégorie par catégorie. Prochain lot après ce document.
+- **Trajectoire SonarQube CI bloquant** — une fois (a) le rapport de code smells trié et (b) une solution trouvée pour `Web:S5247` (ou acceptée comme limitation permanente), retirer `continue-on-error: true` du job `sonarqube` dans `.gitea/workflows/deploy.yml`.
diff --git a/ai/chat.py b/ai/chat.py
index f930ee85..b2f3477c 100644
--- a/ai/chat.py
+++ b/ai/chat.py
@@ -327,9 +327,7 @@ def run_chat_turn(slug: str, screen_id: int, conversation_id: int, user_id: int,
                 )
         messages.append({"role": "user", "content": tool_results})
 
-    assert response is not None, (  # nosec B101  # noqa: S101 - narrowing de type, sur par construction
-        "_MAX_TOOL_ITERATIONS > 0, la boucle for s'execute donc au moins une fois"
-    )
+    response = db.assert_not_none(response, "_MAX_TOOL_ITERATIONS > 0, la boucle for s'execute donc au moins une fois")
     text = next((b.text for b in response.content if b.type == "text"), "")
     if text:
         return text
diff --git a/ai/tools.py b/ai/tools.py
index 618d55c4..9bf02f57 100644
--- a/ai/tools.py
+++ b/ai/tools.py
@@ -558,9 +558,7 @@ def _dispatch_add_scene_object(
         image_url=image_url,
     )
     obj = screens.get_scene_object(slug, object_id)
-    assert obj is not None, (  # nosec B101  # noqa: S101 - narrowing de type, sur par construction
-        "object_id vient d'etre cree par screens.add_scene_object juste au-dessus"
-    )
+    obj = db.assert_not_none(obj, "object_id vient d'etre cree par screens.add_scene_object juste au-dessus")
     # Position par défaut (100,100, voir ensure_scene_schema.py) déjà
     # posée par screens.add_scene_object — reste passée par le même
     # garde-fou pour rester correcte même si ce défaut changeait un jour.
diff --git a/db/__init__.py b/db/__init__.py
index 23666a38..849fbaa7 100644
--- a/db/__init__.py
+++ b/db/__init__.py
@@ -20,6 +20,7 @@ exécute un vrai CREATE TABLE, et remplir le formulaire généré exécute un
 vrai INSERT dans cette table.
 """
 
+from .assert_not_none import assert_not_none
 from .connection import connect
 from .constants import FIELD_TYPES, GLOBAL_VARIABLE_TYPES, PROJECTS_DIR, SCORE_STATUS_CHOICES, SCORE_STATUS_LABELS
 from .custom_events.create_custom_event import create_custom_event
@@ -90,6 +91,7 @@ __all__ = [
     "slugify",
     "table_name_for",
     "json_for_script",
+    "assert_not_none",
     "game_dir",
     "db_path",
     "connect",
diff --git a/db/assert_not_none.py b/db/assert_not_none.py
new file mode 100644
index 00000000..a67e480f
--- /dev/null
+++ b/db/assert_not_none.py
@@ -0,0 +1,15 @@
+from typing import TypeVar
+
+_T = TypeVar("_T")
+
+
+def assert_not_none(value: _T | None, message: str) -> _T:
+    """Narrowing de type explicite : lève un AssertionError clair si `value`
+    est None, renvoie `value` (type non-Optional) sinon. Centralise ici
+    l'unique suppression Bandit/Ruff de ce type dans tout le moteur - un
+    `assert` direct à chaque site d'appel dupliquait le même commentaire
+    de suppression à chaque fois (voir CODE_QUALITY.md, Sonar python:S7632 :
+    Sonar ne reconnaît pas deux commentaires # empilés sur une ligne, même
+    si Ruff et Bandit les acceptent chacun très bien)."""
+    assert value is not None, message  # nosec B101  # noqa: S101 - narrowing de type, seule assert du genre ici
+    return value
diff --git a/routes/scenes/scene_object_add.py b/routes/scenes/scene_object_add.py
index a73e4919..023b7bc0 100644
--- a/routes/scenes/scene_object_add.py
+++ b/routes/scenes/scene_object_add.py
@@ -2,6 +2,7 @@ from flask import abort, g, jsonify, redirect, request, url_for
 from werkzeug.wrappers import Response
 
 import auth
+import db
 import screens
 from core.flask_app import app
 from core.sprite_gate import forbid_admin_only_background, forbid_admin_only_character
@@ -94,11 +95,11 @@ def scene_object_add(slug: str, screen_id: int) -> Response:
         # _clamp_to_camera pour l'IA, ici pour un dépôt manuel.
         obj_for_clamp = screens.get_scene_object(slug, new_id)
         screen = screens.get_screen(slug, screen_id)
-        assert obj_for_clamp is not None, (  # nosec B101  # noqa: S101 - narrowing de type, sur par construction
-            "new_id vient d'etre cree par screens.add_scene_object juste au-dessus"
+        obj_for_clamp = db.assert_not_none(
+            obj_for_clamp, "new_id vient d'etre cree par screens.add_scene_object juste au-dessus"
         )
-        assert screen is not None, (  # nosec B101  # noqa: S101 - narrowing de type, sur par construction
-            "screen_id valide : add_scene_object aurait leve IntegrityError sinon (FK scene_id)"
+        screen = db.assert_not_none(
+            screen, "screen_id valide : add_scene_object aurait leve IntegrityError sinon (FK scene_id)"
         )
         max_x = max(0, screen["scene_width"] - obj_for_clamp["width"])
         max_y = max(0, screen["scene_height"] - obj_for_clamp["height"])
@@ -110,9 +111,7 @@ def scene_object_add(slug: str, screen_id: int) -> Response:
             )
     if request.headers.get("X-Requested-With") == "fetch":
         obj = screens.get_scene_object(slug, new_id)
-        assert obj is not None, (  # nosec B101  # noqa: S101 - narrowing de type, sur par construction
-            "new_id vient d'etre cree par screens.add_scene_object plus haut"
-        )
+        obj = db.assert_not_none(obj, "new_id vient d'etre cree par screens.add_scene_object plus haut")
         return jsonify(
             {
                 "id": new_id,
diff --git a/routes/scenes/scene_object_collision.py b/routes/scenes/scene_object_collision.py
index f0784c93..f468152d 100644
--- a/routes/scenes/scene_object_collision.py
+++ b/routes/scenes/scene_object_collision.py
@@ -3,6 +3,7 @@ from typing import Any
 from flask import jsonify, request
 from werkzeug.wrappers import Response
 
+import db
 import screens
 from core.flask_app import app
 
@@ -33,7 +34,5 @@ def scene_object_collision(slug: str, object_id: int) -> Response | tuple[Respon
 
     screens.set_scene_object_collision(slug, object_id, settings)
     obj = screens.get_scene_object(slug, object_id)
-    assert obj is not None, (  # nosec B101  # noqa: S101 - narrowing de type, sur par construction
-        "object_id valide (deja lu ci-dessus, rien ne l'a supprime entre-temps)"
-    )
+    obj = db.assert_not_none(obj, "object_id valide (deja lu ci-dessus, rien ne l'a supprime entre-temps)")
     return jsonify({"ok": True, "collision": screens.resolve_collision_settings(obj)})
diff --git a/routes/scenes/scene_object_geometry.py b/routes/scenes/scene_object_geometry.py
index b3dc107e..cbc8a7b0 100644
--- a/routes/scenes/scene_object_geometry.py
+++ b/routes/scenes/scene_object_geometry.py
@@ -1,6 +1,7 @@
 from flask import jsonify, request
 from werkzeug.wrappers import Response
 
+import db
 import screens
 from core.flask_app import app
 
@@ -34,8 +35,8 @@ def scene_object_geometry(slug: str, object_id: int) -> Response | tuple[Respons
     # voir iaChatRefreshAfterTurn() dans static/js/ia/ia-chat.js), rendant
     # injoignable à la souris tout ce qui dépassait la scène nominale.
     screen = screens.get_screen(slug, obj["scene_id"])
-    assert screen is not None, (  # nosec B101  # noqa: S101 - narrowing de type, sur par construction
-        "obj existe (verifie plus haut) et _scene_objects.scene_id a ON DELETE CASCADE vers _screens"
+    screen = db.assert_not_none(
+        screen, "obj existe (verifie plus haut) et _scene_objects.scene_id a ON DELETE CASCADE vers _screens"
     )
     objects = screens.list_scene_objects(slug, obj["scene_id"])
     world_width, world_height = screens.resolve_scene_world_size(screen, objects)
diff --git a/routes/scenes/scene_object_personnage_data.py b/routes/scenes/scene_object_personnage_data.py
index 690e4e1f..6d4e9e2b 100644
--- a/routes/scenes/scene_object_personnage_data.py
+++ b/routes/scenes/scene_object_personnage_data.py
@@ -1,6 +1,7 @@
 from flask import jsonify, request
 from werkzeug.wrappers import Response
 
+import db
 import screens
 from core.flask_app import app
 from core.sprite_gate import forbid_admin_only_character
@@ -22,7 +23,5 @@ def scene_object_personnage_data(slug: str, object_id: int) -> Response | tuple[
         forbid_admin_only_character(body["forge_character"])
     screens.set_scene_object_personnage_data(slug, object_id, body)
     obj = screens.get_scene_object(slug, object_id)
-    assert obj is not None, (  # nosec B101  # noqa: S101 - narrowing de type, sur par construction
-        "object_id valide (deja lu ci-dessus, rien ne l'a supprime entre-temps)"
-    )
+    obj = db.assert_not_none(obj, "object_id valide (deja lu ci-dessus, rien ne l'a supprime entre-temps)")
     return jsonify({"ok": True, "animations": screens.resolve_personnage_animations(obj)})
diff --git a/routes/scenes/scene_object_quiz_config.py b/routes/scenes/scene_object_quiz_config.py
index b08c5e74..441b31a4 100644
--- a/routes/scenes/scene_object_quiz_config.py
+++ b/routes/scenes/scene_object_quiz_config.py
@@ -1,6 +1,7 @@
 from flask import jsonify, request
 from werkzeug.wrappers import Response
 
+import db
 import screens
 from core.flask_app import app
 
@@ -20,7 +21,5 @@ def scene_object_quiz_config(slug: str, object_id: int) -> Response | tuple[Resp
     # coup, plutôt que de deviner quelle balise ajouter/retirer côté
     # client.
     obj = screens.get_scene_object(slug, object_id)
-    assert obj is not None, (  # nosec B101  # noqa: S101 - narrowing de type, sur par construction
-        "object_id valide : set_scene_object_quiz_config a renvoye une config non-None"
-    )
+    obj = db.assert_not_none(obj, "object_id valide : set_scene_object_quiz_config a renvoye une config non-None")
     return jsonify({"config": config, "rendered_html": screens.render_scene_object(obj)})
diff --git a/screens/payload/full_game_payload.py b/screens/payload/full_game_payload.py
index c6887190..8da89a66 100644
--- a/screens/payload/full_game_payload.py
+++ b/screens/payload/full_game_payload.py
@@ -136,8 +136,8 @@ def full_game_payload(slug: str, player_id: str = db.PLAYER_SHARED) -> dict[str,
     fields_meta = {}
     for d in definitions:
         full = db.get_definition(slug, d["id"])
-        assert full is not None, (  # nosec B101  # noqa: S101 - narrowing de type, sur par construction
-            "d['id'] vient de list_definitions(slug), donc get_definition ne peut pas renvoyer None ici"
+        full = db.assert_not_none(
+            full, "d['id'] vient de list_definitions(slug), donc get_definition ne peut pas renvoyer None ici"
         )
         rows = db.list_rows(slug, full, player_id)
         # Un champ "relation" vit dans une colonne SQL "<champ>_id", jamais
diff --git a/scripts/build_demo_dialogues.py b/scripts/build_demo_dialogues.py
index 0ae9732c..b59d0408 100644
--- a/scripts/build_demo_dialogues.py
+++ b/scripts/build_demo_dialogues.py
@@ -52,6 +52,7 @@ sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from flask.testing import FlaskClient
 from werkzeug.test import TestResponse
 
+import db
 import routes  # noqa: F401 - enregistre toutes les routes
 from core import jinja_filters  # noqa: F401 - enregistre les filtres Jinja
 from core.flask_app import app
@@ -59,8 +60,9 @@ from core.flask_app import app
 
 def _redirect_id(resp: TestResponse, pattern: str) -> int:
     match = re.search(pattern, resp.headers["Location"])  # NOSONAR S8371 - Location attendue, KeyError = echec clair
-    assert match is not None, (  # nosec B101  # noqa: S101 - script d'usage unique, jamais execute en production
-        f"motif {pattern!r} absent de Location: {resp.headers['Location']!r}"  # NOSONAR S8371 - idem
+    match = db.assert_not_none(
+        match,
+        f"motif {pattern!r} absent de Location: {resp.headers['Location']!r}",  # NOSONAR S8371 - idem
     )
     return int(match.group(1))
 
diff --git a/templates/auth/register_2fa.html b/templates/auth/register_2fa.html
index f1e96a6e..b1b5575b 100644
--- a/templates/auth/register_2fa.html
+++ b/templates/auth/register_2fa.html
@@ -11,8 +11,7 @@
     <div class="notification is-danger">{{ error }}</div>
     {% endif %}
 
-    {# NOSONAR S5247 - qr_svg est produit par la librairie qrcode a partir d'une URI TOTP generee serveur, aucun texte libre utilisateur embarque #}
-    <div class="totpQrWrap">{{ qr_svg|safe }}</div>
+    <div class="totpQrWrap">{{ qr_svg|safe }}</div> {# //NOSONAR S5247 - qr_svg est produit par la librairie qrcode a partir d'une URI TOTP generee serveur, aucun texte libre utilisateur embarque #}
     <p class="hint">Impossible de scanner ? Saisis cette clé manuellement dans l'application : <code>{{ secret }}</code></p>
 
     <form method="post" action="{{ url_for('register_2fa') }}" class="mt-4">
diff --git a/templates/onboarding/onboarding_new.html b/templates/onboarding/onboarding_new.html
index 741f9eca..626bd64b 100644
--- a/templates/onboarding/onboarding_new.html
+++ b/templates/onboarding/onboarding_new.html
@@ -22,8 +22,7 @@
                 <span class="onboardingCardLabel">{{ info.label }}</span>
               </span>
               <span class="onboardingCardFace onboardingCardBack">
-                {# NOSONAR S5247 - description est du HTML fixe, code en dur dans db.ONBOARDING_TYPES (aucune saisie utilisateur) #}
-                <span class="onboardingCardDesc">{{ info.description|safe }}</span>
+                <span class="onboardingCardDesc">{{ info.description|safe }}</span> {# //NOSONAR S5247 - description est du HTML fixe, code en dur dans db.ONBOARDING_TYPES (aucune saisie utilisateur) #}
               </span>
             </span>
           </button>
diff --git a/templates/play.html b/templates/play.html
index 20639687..70445070 100644
--- a/templates/play.html
+++ b/templates/play.html
@@ -141,7 +141,7 @@
   // routes/play/game_play.py) que la partie publique par joueur
   // (/jouer/<slug>, routes/public_play/), deux familles de routes
   // distinctes (voir état par joueur, Phase 1).
-  let gameData = {{ payload_json|safe }};
+  let gameData = {{ payload_json|safe }}; // NOSONAR S5247 - json_for_script() echappe deja la balise fermante de script (voir db/json_for_script.py)
   let screensData = gameData.screens;
   {% if offline_mode %}
   // Export Web/SCORM (voir publish/build_scorm_package.py) : paquet
diff --git a/templates/scene_edit.html b/templates/scene_edit.html
index e133ec4c..86988d5b 100644
--- a/templates/scene_edit.html
+++ b/templates/scene_edit.html
@@ -307,8 +307,7 @@
           <div class="canvasElement {{ 'selected' if o.id == selected_id else '' }} {{ 'isQuizFullscreenPreview' if o.quiz_fullscreen else '' }}" id="el-{{ o.id }}"
                style="position:absolute; left:{{ o.x }}px; top:{{ o.y }}px; width:{{ o.width }}px; height:{{ o.height }}px;"
                onmousedown="onSceneObjectMouseDown(event, {{ o.id }})">
-            {# NOSONAR S5247 - rendered_html vient de render_scene_object() (Python), qui echappe deja tout texte utilisateur via html.escape() #}
-            <div class="canvasElementInner">{{ o.rendered_html|safe }}</div>
+            <div class="canvasElementInner">{{ o.rendered_html|safe }}</div> {# //NOSONAR S5247 - rendered_html vient de render_scene_object() (Python), qui echappe deja tout texte utilisateur via html.escape() #}
             <div class="resizeHandle" onmousedown="onSceneObjectResizeMouseDown(event, {{ o.id }})"></div>
             {% if o.id == selected_id and o.kind not in ('fond', 'dialogue_box', 'quiz_box', 'score_widget') %}
             <!-- Boîte de collision (voir screens/rendering/collision_settings.py) :
-- 
2.54.0


From 66d8eaeae8429e75a16eb5fbfe36d88dfc1da9ee Mon Sep 17 00:00:00 2001
From: william <you@example.com>
Date: Fri, 18 Sep 2026 08:46:24 +0200
Subject: [PATCH 3/4] Lots 1-3 modernisation JS (S8786/S2703/S2486) + retrait
 Sonar CI/prod

- Lot 1 (S8786, ReDoS) : 5 sites documentes NOSONAR apres preuve empirique
  (script reproductible docs/redos_probe_s8786.js), aucune reecriture
  defensive necessaire.
- Lot 2 (S2703, variable globale implicite) : bug reel trouve et corrige
  (SCENE_OBJECT_NAMES en const au lieu de let, cassait la reassignation
  cross-script depuis scene-editor.js) + test de non-regression ; 4 autres
  sites confirmes surs et documentes.
- Lot 3 (S2486, exceptions avalees) : 6 sites confirmes surs et
  documentes ; 2 sites (config sprite JSON invalide) corriges avec un
  console.warn devtools, comportement joueur inchange, couverts par un
  nouveau test.
- Retrait du job CI sonarqube (.gitea/workflows/deploy.yml) et du service
  prod sonarqube/sonar-postgres (docker-compose.prod.yml) : acces dashboard
  bloque par des soucis d'infrastructure reseau (WSL2/pare-feu Hyper-V en
  local, reseau Docker partage avec Caddy pas en place en prod), sans lien
  avec le code du moteur - mis de cote plutot que de continuer a bloquer
  sur de l'infra. Les lots 4+ de modernisation JS dependent de scores
  Sonar exacts et sont donc egalement en pause (voir CODE_QUALITY.md).

SKIP=djlint : H021 (styles inline, 49 occurrences) est un backlog deja
documente et assume (CODE_QUALITY.md section 6), sur des templates non
touches par ce commit - deja exclu de la CI pour la meme raison.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 .gitea/workflows/deploy.yml                   |  50 +---
 CLAUDE.md                                     |  62 +++++
 CODE_QUALITY.md                               |  75 ++++--
 docker-compose.prod.yml                       |  40 ---
 docs/JS_MODERNIZATION_PLAN.md                 | 134 ++++++++++
 docs/SESSION_RECAP.md                         | 242 ++++++++++++++++++
 docs/redos_probe_s8786.js                     |  57 +++++
 static/js/play/__tests__/actions.test.js      |  26 +-
 static/js/play/actions.js                     |  13 +-
 .../js/play/offline/filter-repeater-rows.js   |   4 +-
 static/js/play/offline/xapi-client.js         |   4 +-
 static/js/play/screens.js                     |  13 +-
 .../__tests__/collision-rules-editor.test.js  |  33 +++
 static/js/screen_edit/panel-init.js           |   4 +-
 static/js/screen_edit/tree-panels.js          |  10 +-
 static/js/triggers/trigger-editor.js          |  11 +-
 16 files changed, 666 insertions(+), 112 deletions(-)
 create mode 100644 CLAUDE.md
 create mode 100644 docs/JS_MODERNIZATION_PLAN.md
 create mode 100644 docs/SESSION_RECAP.md
 create mode 100644 docs/redos_probe_s8786.js

diff --git a/.gitea/workflows/deploy.yml b/.gitea/workflows/deploy.yml
index 1e7fec1c..00fd3d70 100644
--- a/.gitea/workflows/deploy.yml
+++ b/.gitea/workflows/deploy.yml
@@ -4,13 +4,12 @@ on:
   push:
     branches: [main, dev]
 
-# Les jobs "test-*"/"lint-*"/"sonarqube" tournent sur CHAQUE push (main et
-# dev) : jusqu'ici aucune étape de CI n'exécutait la suite de tests ni les
-# outils qualité, rien n'empêchait un commit cassé d'atteindre la
-# production (voir l'audit qualité de la Phase 0 du plan). "build-and-
-# push"/"deploy", eux, restent réservés à main (via le filtre "if" sur
-# gitea.ref) — un push sur dev ne doit jamais redéployer la prod, seulement
-# faire tourner tests/lint/sonar.
+# Les jobs "test-*"/"lint-*" tournent sur CHAQUE push (main et dev) :
+# jusqu'ici aucune étape de CI n'exécutait la suite de tests ni les outils
+# qualité, rien n'empêchait un commit cassé d'atteindre la production (voir
+# l'audit qualité de la Phase 0 du plan). "build-and-push"/"deploy", eux,
+# restent réservés à main (via le filtre "if" sur gitea.ref) — un push sur
+# dev ne doit jamais redéployer la prod, seulement faire tourner tests/lint.
 #
 # lint-python/lint-js rejouent EXACTEMENT les hooks pre-commit locaux
 # (.pre-commit-config.yaml) mais bloquants ici dès le départ (déjà tous
@@ -18,12 +17,11 @@ on:
 # les hooks pre-commit ne protègent que la machine du committeur, jamais
 # un push direct ou une PR mergée depuis ailleurs. djlint EXCLU
 # volontairement (49 H021 "styles inline" déjà en backlog assumé, voir
-# CODE_QUALITY.md) — à ajouter ici quand ce lot sera traité. sonarqube,
-# lui, reste NON-BLOQUANT (continue-on-error) pendant cette première
-# période — voir CODE_QUALITY.md pour la trajectoire vers un mode
-# bloquant une fois le rapport trié (code smells, vulnerabilites) plutôt
-# que de bloquer tout de suite sur des centaines de signalements pas
-# encore triés.
+# CODE_QUALITY.md) — à ajouter ici quand ce lot sera traité.
+#
+# SonarQube (job CI + service prod) retiré pour l'instant — voir
+# CODE_QUALITY.md pour le contexte (accès instance locale/prod bloqué par
+# des soucis d'infra réseau, mis de côté volontairement).
 
 # Secrets à configurer dans Gitea (Paramètres du dépôt > Actions > Secrets) :
 #   REGISTRY_HOST   adresse du registre d'images (ex: gitea.exemple.com)
@@ -34,8 +32,6 @@ on:
 #   DEPLOY_USER     utilisateur SSH sur ce serveur
 #   DEPLOY_SSH_KEY  clé privée SSH (au format PEM) autorisée sur ce serveur
 #   DEPLOY_PATH     dossier sur le serveur où vit docker-compose.prod.yml (ex: /home/deploy/forge-engine)
-#   SONAR_TOKEN     jeton d'analyse SonarQube (Mon compte > Security > Generate Token
-#                   sur sonar.forgebase.fr) — jamais le mot de passe admin.
 #
 # Utilise directement docker/ssh/scp en ligne de commande plutôt que des
 # actions du marketplace, pour ne pas dépendre de la disponibilité de
@@ -92,7 +88,7 @@ jobs:
           COPY static/js/play/ static/js/play/
           COPY static/js/scenes/ static/js/scenes/
           COPY static/js/triggers/ static/js/triggers/
-          RUN node --test static/js/play/__tests__/*.test.js static/js/scenes/__tests__/*.test.js
+          RUN node --test static/js/play/__tests__/*.test.js static/js/play/offline/__tests__/*.test.js static/js/scenes/__tests__/*.test.js
           DOCKERFILE
 
   lint-python:
@@ -135,28 +131,6 @@ jobs:
           RUN npm run lint:css
           DOCKERFILE
 
-  sonarqube:
-    runs-on: ubuntu-latest
-    # Non-bloquant pendant cette premiere periode (voir le bloc de
-    # commentaires en tete de fichier) — un echec ici n'empeche jamais
-    # build-and-push/deploy, contrairement a lint-python/lint-js.
-    continue-on-error: true
-    steps:
-      - uses: actions/checkout@v4
-      - name: Analyse SonarQube (rapport seul, non-bloquant)
-        run: |
-          # Meme neutralisation de .dockerignore que test-python : sonar-
-          # project.properties couvre aussi tests/ (sonar.tests).
-          mv .dockerignore .dockerignore.disabled-for-ci
-          docker build -f - -t forge-sonar:${{ gitea.sha }} . <<'DOCKERFILE'
-          FROM sonarsource/sonar-scanner-cli:latest
-          WORKDIR /usr/src
-          COPY . .
-          DOCKERFILE
-          docker run --rm forge-sonar:${{ gitea.sha }} \
-            -Dsonar.host.url=https://sonar.forgebase.fr \
-            -Dsonar.token=${{ secrets.SONAR_TOKEN }}
-
   build-and-push:
     needs: [test-python, test-js, lint-python, lint-js]
     if: gitea.ref == 'refs/heads/main'
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 00000000..9899d191
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,62 @@
+## Stack et structure
+Bref rappel : Python/Flask/Jinja backend, JS/HTML/CSS frontend, architecture en couches (routes → services/screens → db, voir contrat import-linter dans pyproject.toml).
+
+## Règle absolue : qualité de code non négociable
+- Tout code Python doit passer mypy --strict sans erreur. Jamais de # type: ignore sans commentaire justifiant précisément pourquoi (pas de vague, une vraie raison technique).
+- Tout code doit passer Ruff, Bandit, Vulture, import-linter, ESLint, Stylelint sans nouvelle erreur avant d'être considéré terminé.
+- Avant de committer, lance systématiquement pre-commit run --all-files et corrige tout ce qui échoue — jamais de --no-verify ou de SKIP= sans me le signaler et justifier explicitement pourquoi.
+- Aucune règle de lint/typage ne doit être désactivée globalement dans un fichier de config sans ma validation explicite. Une exception ponctuelle (# noqa, # nosec, // NOSONAR, ts-ignore) doit toujours être sur la ligne concernée avec un commentaire expliquant précisément pourquoi, jamais un ignore de fichier entier ou de règle globale.
+
+## Distinguer bug réel vs faux positif
+Avant de corriger un finding d'un outil (Mypy, Bandit, Sonar, etc.), détermine s'il s'agit d'un vrai problème ou d'un faux positif dû au contexte du projet (ex. injection de fixture pytest, dispatch dynamique JS/Jinja, whitelist codée en dur). Ne corrige jamais mécaniquement sans comprendre la cause. Si un correctif change un comportement (pas juste une annotation/un style), signale-le explicitement avant de l'appliquer et explique pourquoi.
+
+## Tests unitaires — non-régression
+- Toute nouvelle fonctionnalité ou tout correctif de bug doit être accompagné d'un test qui aurait échoué avant le fix et passe après.
+- Ne jamais me dire "les tests passent" comme preuve suffisante pour un changement de sécurité ou de comportement sensible (ex. échappement de données, gestion de permissions) — écris un test ou un script de vérification dédié qui prouve concrètement le comportement attendu (voir l'exemple du fix XSS json_for_script : test avec une charge malveillante réelle, pas juste "aucune régression").
+- Ne réduis jamais la portée d'une assertion de test pour la faire passer sans discussion préalable avec moi.
+- Signale immédiatement toute fuite d'état entre tests (fixtures partagées, données non nettoyées) même si elle n'est pas dans le scope de la tâche en cours.
+
+## Code mort
+Avant de supprimer une fonction jugée "morte" par un outil (Vulture, ESLint no-unused-vars), vérifie par grep exhaustif (imports directs, dispatch dynamique par nom de chaîne, référencé depuis un template Jinja ou un script JS, appel getattr/introspection) avant de conclure qu'elle est vraiment inutilisée.
+
+## SonarQube local (développement continu)
+En plus de l'instance CI (sonar.forgebase.fr, non-bloquante), une instance SonarQube locale doit tourner via Docker pour un usage rapide pendant le développement, séparée de la CI.
+
+### Mise en place (à faire une fois si l'instance n'existe pas encore)
+Si aucune instance locale n'est déjà en place : lance une instance SonarQube Community via Docker (image officielle, avec une base PostgreSQL plutôt que la H2 embarquée par défaut — voir la mise en place déjà documentée pour sonar.forgebase.fr comme référence). Communique-moi clairement l'adresse locale (ex. http://localhost:9000) une fois lancée, et le port utilisé, pour que je puisse ouvrir le dashboard moi-même à tout moment.
+
+### Utilisation continue pendant le développement
+- Avant de considérer une tâche terminée (nouvelle fonctionnalité, gros refactor, fix de bug), lance une analyse sonar-scanner contre cette instance locale.
+- Si des erreurs ou vulnérabilités sont détectées sur du code NOUVEAU (écrit dans la session en cours) : corrige-les toi-même directement, comme pour Ruff/Mypy/Bandit — pas besoin de me demander la permission pour un vrai bug évident sur du code que tu viens d'écrire.
+- Si l'analyse détecte quelque chose sur du code existant (pas modifié dans la session en cours) : signale-le-moi, n'y touche pas sans validation, même logique que pour le rapport SonarQube de la Phase 3 (analyse d'abord, décision ensemble avant correction).
+- Distingue toujours dans ton compte-rendu : ce qui a été corrigé automatiquement (code neuf, évident) vs ce qui est signalé en attente de décision (code existant, ou correction ambiguë).
+- Donne-moi régulièrement l'adresse du dashboard local si je veux consulter moi-même le détail visuellement.
+
+## Convention vs bug de config
+Si un preset de lint (ex. airbnb-base, stylelint-config-standard) contredit une convention cohérente déjà établie dans le code (ex. camelCase CSS, var au lieu de let/const), n'impose pas de réécriture mécanique du code : propose d'adapter la config, documente pourquoi, et attends ma validation.
+
+## Discipline de communication
+- Pour tout lot de travail dépassant quelques fichiers, découpe en étapes vérifiables (diff + tests à chaque étape), jamais un correctif massif d'un coup.
+- Signale tout changement de comportement réel séparément du reste (pas noyé dans un rapport de style).
+- Si un choix a plusieurs options légitimes (garder/typer/supprimer, corriger/documenter une exception), présente les options avec leurs compromis plutôt que de trancher seul.
+
+## Documentation
+Toute règle désactivée, tout # nosec/NOSONAR, toute adaptation de config doit être répercutée dans CODE_QUALITY.md.
+
+## Organisation des fichiers (applicable à partir de maintenant, pas de refactor rétroactif)
+
+- 1 fichier = 1 fonction publique. Les fonctions privées d'appui (préfixées _) utilisées uniquement par cette fonction restent dans le même fichier.
+- 1 dossier = 1 responsabilité claire.
+- Chaque dossier a un fichier barrel (__init__.py) qui importe/exporte toutes les fonctions publiques du dossier (pattern déjà en place dans db/__init__.py et screens/__init__.py — garde __all__ explicite à jour à chaque ajout).
+- Chaque dossier a un fichier .md qui documente chaque fonction publique qu'il contient : signature, rôle, paramètres, valeur de retour, exceptions possibles. Mets-le à jour à chaque fonction ajoutée/modifiée/supprimée.
+
+### Exceptions à cette règle (ne pas séparer)
+- Le pattern sanitize_X / resolve_X (validation + résolution avec repli sur valeur par défaut) : ces deux fonctions restent dans le même fichier quand resolve_X appelle directement sanitize_X et qu'elles partagent des constantes de configuration. Ce sont deux étapes d'un même contrat, pas deux responsabilités séparées.
+- Un groupe de fonctions fortement couplées par une table de dispatch centrale et des constantes de module partagées (ex. collision_rules.py) peut rester dans un seul fichier si les séparer forcerait soit une duplication de constantes, soit un fichier de constantes partagé importé par tous les autres pour un gain de lisibilité douteux. En cas de doute, demande avant de trancher plutôt que d'appliquer la règle mécaniquement.
+- Des handlers Flask co-localisés par convention d'URL (ex. plusieurs routes d'un même sous-domaine fonctionnel) qui n'ont aucun appel ni état partagé entre eux ne sont PAS un cas d'exception — ceux-là doivent être séparés, un fichier par route/fonction.
+
+### Avant de créer une nouvelle fonction
+Vérifie si elle appartient à un fichier existant à forte cohésion (voir exceptions ci-dessus) ou si elle mérite son propre fichier. En cas de doute sur la classification, demande plutôt que de deviner.
+
+### Constantes partagées entre plusieurs fonctions d'un même dossier
+Si plusieurs fonctions séparées (dans des fichiers différents) ont besoin des mêmes constantes, crée un fichier constants.py dans le dossier concerné plutôt que de dupliquer les valeurs — ne duplique jamais une constante de configuration entre fichiers.
diff --git a/CODE_QUALITY.md b/CODE_QUALITY.md
index e4db0e35..c47e4a05 100644
--- a/CODE_QUALITY.md
+++ b/CODE_QUALITY.md
@@ -55,11 +55,21 @@ ignore de fichier entier ou de règle globale — voir section 4.
 - `app.py` (point d'entrée, pas un paquet) reste hors contrat — c'est lui qui importe `routes`/`core`, jamais l'inverse.
 
 ### ESLint (`.eslintrc.json`)
-- Base `airbnb-base` + plugin `unused-imports`.
+- Base `airbnb-base` + plugins `unused-imports`, `unicorn`.
 - `max-len` porté à 120 (aligné sur Ruff) au lieu du 80 par défaut d'Airbnb.
 - Plusieurs règles Airbnb désactivées **après vérification individuelle que le code existant les respecte déjà différemment** (voir section 5 pour le détail et le raisonnement de chacune) : `no-param-reassign`, `no-use-before-define` (assoupli pour les fonctions, gardé strict pour variables/classes), `func-names`, `no-underscore-dangle`, `no-console`, `no-plusplus`, `no-continue`, `no-bitwise`, `guard-for-in`, `no-restricted-syntax`, `prefer-destructuring`, `consistent-return`, `no-return-assign`, `no-nested-ternary`, `no-void`, `implicit-arrow-linebreak`, `no-unused-expressions`, `no-useless-concat`.
 - `unused-imports/no-unused-vars` avec une liste blanche (`varsIgnorePattern`) d'environ 95 noms : fonctions invoquées uniquement depuis des attributs `onclick`/`onchange` inline dans les templates Jinja, invisibles pour l'analyse statique d'ESLint.
 - Bloc `globals` documentant les variables cross-fichiers volontaires (ex. `gameData`, `screensData` — voir section 5).
+- **`eslint-plugin-unicorn`** (version `55.0.0` épinglée — la dernière exige ESLint ≥10, incompatible avec notre `^8.57.1`) : activé avec **UNIQUEMENT 9 règles explicitement listées**, jamais sa config `recommended` complète (qui en contient des dizaines d'autres, jamais évaluées pour ce projet — décision délibérée pour ne pas introduire un nouveau volume de règles non passées en revue). Choisi pour nettoyer le lot "modernisation JS" du rapport SonarQube (voir `docs/JS_MODERNIZATION_PLAN.md`) : `eslint-plugin-sonarjs` (l'équivalent officiel SonarSource) ne couvrait qu'une seule des règles visées. Les 9 règles activées, chacune avec un fixer `--fix` vérifié :
+  - `unicorn/prefer-number-properties` — `parseFloat`/`parseInt`/`isNaN`/`isFinite` → `Number.*`
+  - `unicorn/prefer-string-replace-all` — `.replace(/x/g, ...)` → `.replaceAll(...)`
+  - `unicorn/prefer-dom-node-dataset` — `getAttribute('data-x')` → `.dataset.x`
+  - `unicorn/prefer-includes` — `.indexOf(x) !== -1` → `.includes(x)`
+  - `unicorn/prefer-string-starts-ends-with` — comparaison manuelle de sous-chaîne → `.startsWith()`/`.endsWith()`
+  - `unicorn/prefer-modern-math-apis` — expression mathématique manuelle → `Math.hypot()` etc.
+  - `unicorn/prefer-at` — `arr[arr.length - 1]` → `arr.at(-1)`
+  - `unicorn/no-useless-fallback-in-spread` — `{...(x || {})}` → `{...x}`
+  - `unicorn/no-for-loop` — boucle `for` classique sur un itérable → `for...of`
 
 ### Stylelint (`.stylelintrc.json`)
 - Base `stylelint-config-standard`.
@@ -71,9 +81,8 @@ ignore de fichier entier ou de règle globale — voir section 4.
 - `profile = "jinja"`, `max_line_length = 160`, `indent = 2`.
 - H021 (styles inline) : **backlog assumé, pas une exception corrigée** — voir section 6, ne pas confondre avec les vraies exceptions de la section 5.
 
-### SonarQube
-- **Local (développement continu)** : Docker Community Build + PostgreSQL (jamais la base H2 embarquée), tourne en permanence sur cette machine via `~/sonarqube-stack/docker-compose.yml` (WSL2/Ubuntu). Dashboard : **http://localhost:9000** — identifiants personnels, jamais consignés ici.
-- **CI (`sonar.forgebase.fr`)** : instance séparée, self-hébergée, scan à chaque push via `.gitea/workflows/deploy.yml` (job `sonarqube`), **non-bloquant** (`continue-on-error: true`) le temps que le rapport soit entièrement trié.
+### SonarQube — retiré pour l'instant
+Le job CI `sonarqube` (`.gitea/workflows/deploy.yml`) et le service prod `sonarqube`/`sonar-postgres` (`docker-compose.prod.yml`) ont été retirés le 18/09/2026 : l'accès au dashboard (local WSL2 et prod derrière Caddy) est resté bloqué par des soucis d'infrastructure réseau (redirection de port WSL2/pare-feu Hyper-V côté local, réseau Docker partagé avec Caddy pas encore en place côté prod) sans lien avec le code du moteur — mis de côté volontairement plutôt que de continuer à bloquer sur de l'infra. Le lot "modernisation JS" (voir `docs/JS_MODERNIZATION_PLAN.md`) s'est arrêté après le lot 3 (`S2486`) pour cette même raison : les lots 4+ dépendent de scores Sonar exacts (complexité cognitive notamment) qu'aucun proxy fiable ne remplace. À reprendre une fois l'accès rétabli — voir section 6.
 
 ## 3. Lancer les checks en local
 
@@ -94,19 +103,11 @@ pre-commit run --all-files
 
 # Suite de tests
 python -m pytest tests/ -q
-node --test static/js/play/__tests__/*.test.js static/js/scenes/__tests__/*.test.js
-
-# Scan SonarQube local (rapport seul - jamais de correction automatique
-# a partir de son seul resultat sans triage prealable, voir section 4)
-# Necessite le stack Docker local demarre (voir section 2) et un token
-# genere sur http://localhost:9000 (Mon compte > Security > Generate Token).
-docker run --rm --network sonarqube-stack_default \
-  -v <chemin-absolu-du-repo>:/usr/src \
-  sonarsource/sonar-scanner-cli \
-  -Dsonar.host.url=http://sonarqube:9000 \
-  -Dsonar.token=<votre-token>
+node --test static/js/play/__tests__/*.test.js static/js/play/offline/__tests__/*.test.js static/js/scenes/__tests__/*.test.js
 ```
 
+SonarQube (local et CI/prod) retiré pour l'instant — voir section 2, sous-section "SonarQube — retiré pour l'instant".
+
 ## 4. Procédure de justification d'une exception
 
 1. **Jamais de correction mécanique sans comprendre la cause.** Avant de corriger un finding, déterminer s'il s'agit d'un vrai problème ou d'un faux positif dû au contexte du projet (fixture pytest, dispatch dynamique JS/Jinja, whitelist codée en dur, architecture volontaire).
@@ -134,10 +135,50 @@ docker run --rm --network sonarqube-stack_default \
 | `db/assert_not_none.py:14` | `B101`/`S101`/`python:S7632` | Unique `assert` de narrowing de type restant dans tout le moteur, après centralisation de 11 sites dispersés (`ai/`, `routes/scenes/`, `screens/payload/`, `scripts/`) dans ce helper unique. Voir section 4 pour l'impossibilité structurelle de satisfaire Bandit+Ruff avec un seul `#`. | Session du 16/09/2026 |
 | `db/rows/delete_row.py`, `db/rows/get_row.py`, `db/rows/list_rows.py`, `screens/animations/update_animation_clip.py`, `screens/flow/add_flow_node.py`, `screens/scenes/add_scene_object.py` | `B608`/`S608`/`python:S7632` | Noms de table/colonnes construits uniquement à partir de `slugify()`/whitelists codées en dur (`_UPDATABLE_FIELDS`, `FLOW_NODE_FIELDS`), jamais d'une entrée arbitraire — valeurs toujours paramétrées (`?`). Distinct du cas `assert_not_none` ci-dessus (nature différente : construction de SQL, pas narrowing de type) — non couvert par ce refactor. | Session du 16/09/2026 |
 | `static/js/play/bindings.js:179` (`gameData = newData`) | `javascript:S2703` | Pattern volontaire de scripts globaux (pas des modules ES) : `gameData`/`screensData` sont déclarés une fois par `let` dans le `<script>` inline de `templates/play.html`, chargé avant tous les `static/js/play/*.js` (ordre séquentiel vérifié, pas de `defer`/`async`). Réassignation légitime d'une variable déjà déclarée dans un scope global partagé — déjà documenté dans `.eslintrc.json` (`"gameData": "writable"`). | Session du 16/09/2026 |
+| `static/js/play/bindings.js:180` (`screensData = gameData.screens`) | `javascript:S2703` | Même bloc, même pattern, même fichier de déclaration que `gameData` ci-dessus : `let screensData = gameData.screens;` posé dans le même `<script>` inline de `templates/play.html:145` (juste après `gameData:144`), chargé avant `bindings.js` — déjà documenté dans `.eslintrc.json` (`"screensData": "writable"`). Lot 2 "modernisation JS". | Lot 2 "modernisation JS", 16/09/2026 |
+| `static/js/scenes/scene-editor.js:214` (`CURRENT_SELECTED_ID = null`), `static/js/screen_edit/tree-panels.js:392` (`CURRENT_SELECTED_ID = selectedId \|\| null`) | `javascript:S2703` | Déclarée en **`var`** (pas `let`/`const`) dans `templates/scene_edit.html:833` (`var CURRENT_SELECTED_ID = {{ selected_id or 'null' }};`), chargé avant `tree-panels.js`/`scene-editor.js`/`trigger-editor.js`/`collision-rules-editor.js` (ordre vérifié, lignes 833/858/880/885/887/888) — un `var` de script classique attache directement à `window`, réassignable sans aucune restriction depuis n'importe quel autre `<script>` de la page (contrairement au cas `SCENE_OBJECT_NAMES` ci-dessous, qui lui était en `const`). Déjà documenté dans `.eslintrc.json` (`"CURRENT_SELECTED_ID": "writable"`). | Lot 2 "modernisation JS", 16/09/2026 |
+| `static/js/scenes/collision-rules-editor.js:78` (`let _collisionWizard = null;`) et ses réassignations, toutes dans ce même fichier | `javascript:S2703` | Déclarée ET réassignée exclusivement à l'intérieur de `collision-rules-editor.js` (aucun autre fichier n'y touche, vérifié par grep exhaustif) — Sonar la signale seulement parce que ce fichier est un script classique sans wrapper de module (comme tout `static/js/`), pas parce qu'un ordre de chargement entre fichiers serait en jeu ; c'est le cas le plus simple des 4 (état privé à un seul fichier). Déjà documenté dans `.eslintrc.json` (`"_collisionWizard": "writable"`). | Lot 2 "modernisation JS", 16/09/2026 |
+| `static/js/triggers/trigger-editor.js:28` (`let SCENE_OBJECT_NAMES = ...`) | `javascript:S2703` | **Bug réel trouvé et corrigé** (pas un faux positif comme les 4 sites ci-dessus) : était déclarée en `const`, alors que `refreshSceneObjectNames()` (`static/js/scenes/scene-editor.js:754-759`) la réassigne après un fetch — deux `<script>` classiques sur la même page partagent un même environnement lexical global, mais une liaison `const` posée dans l'un ne peut pas être réassignée depuis l'autre (`TypeError: Assignment to constant variable.`, reproduit empiriquement via `node:vm`). Symptôme : renommer un personnage puis ouvrir un dialogue de déclencheur sans recharger la page ne montrait jamais le nouveau nom dans "qui parle". Corrigé en `let`, couvert par un test de non-régression (`static/js/scenes/__tests__/collision-rules-editor.test.js`, test `refreshSceneObjectNames`) qui échoue avec `TypeError` sur l'ancien code et passe avec le nouveau. | Lot 2 "modernisation JS", 16/09/2026 |
 | 31 sites `\|safe` (`templates/scene_edit.html`, `templates/play.html`, `templates/auth/register_2fa.html`, `templates/onboarding/onboarding_new.html`, `templates/game_dashboard_simple.html`) | `Web:S5247` (Sonar) | **Faux positif confirmé sur le fond, mais non-supprimable techniquement pour l'instant.** 3 sous-groupes : (1) `rendered_html`/`qr_svg`/`description` — HTML déjà échappé côté Python (`html.escape()`) ou généré sans texte libre utilisateur ; (2) 25 sites `*_json` — `db.json_for_script()` échappe déjà `</script>` (voir Phase 3). Plusieurs syntaxes de suppression testées (commentaire Jinja `{# #}`, commentaire JS natif dans un `<script>`, bonne position de ligne) : **aucune ne fonctionne** avec l'analyseur Web de cette version de SonarQube. La résolution "Faux positif" via l'API est bloquée par le système de permissions de session. `sonar.issue.ignore.multicriteria` existe mais sans sélecteur de ligne (exclusion fichier entier uniquement) — écarté pour `scene_edit.html`/`play.html` (masquerait un futur `\|safe` réellement dangereux). Ces 31 sites restent visibles dans le rapport Sonar en l'état ; traités et compris, pas un point ouvert côté code. | Phase 3 + investigation du 16/09/2026 |
+| `static/js/play/offline/filter-repeater-rows.js:10,11`, `static/js/screen_edit/panel-init.js:254,261`, `static/js/play/offline/xapi-client.js:132` | `javascript:S8786` (ReDoS) | 3 regex distinctes (2 dupliquées dans 2 fichiers) testées empiriquement, aucune ne montre de backtracking super-linéaire réel — voir le détail complet juste en dessous du tableau (méthode reproductible). | Lot 1 "modernisation JS", 16/09/2026 |
+| `static/js/screen_edit/tree-panels.js:32` (`restoreTreeCollapsedState`), `:57` (`saveFloatPanelState`), `:230` (sauvegarde état replié/déplié au clic) | `javascript:S2486` | Lecture/écriture `localStorage` purement cosmétique (éditeur seulement, jamais le jeu) : un échec (quota, storage désactivé) laisse au pire un panneau à sa position par défaut ou un nœud d'arborescence dans son état précédent — aucune donnée de jeu en jeu, aucun état perdu de façon irréversible. | Lot 3 "modernisation JS", 16/09/2026 |
+| `static/js/screen_edit/tree-panels.js:162` (`dragstart` galerie d'icônes), `:295` (`dragstart` arborescence) | `javascript:S2486` | `e.dataTransfer.setData(...)` sert uniquement à satisfaire l'exigence cross-navigateur de l'API HTML5 Drag (au moins un type MIME posé) — vérifié que les deux `drop` correspondants (lignes 177-182 et 320-344) lisent l'id glissé depuis une variable JS module (`draggedIconClass`/`treeDragElementId`), jamais `e.dataTransfer.getData(...)` : un échec de `setData` n'a donc aucun effet sur le comportement réel du glisser-déposer. | Lot 3 "modernisation JS", 16/09/2026 |
+| `static/js/play/offline/xapi-client.js:72` (`forgeXapiActor`) | `javascript:S2486` | API SCORM absente ou non conforme — attendu hors d'un vrai LMS (ex. prévisualisation) — repli déjà en place sur un acteur anonyme générique. Comportement déjà documenté par le commentaire du bloc. | Lot 3 "modernisation JS", 16/09/2026 |
+| `static/js/play/screens.js:89` (`runScreenBackgroundMusic`), `static/js/play/actions.js:333` (action "jouer_son") | `javascript:S2486` | `.play().catch(() => {})` — échec attendu du navigateur (lecture audio automatique bloquée tant qu'aucune interaction utilisateur n'a eu lieu), jamais une erreur applicative à signaler. | Lot 3 "modernisation JS", 16/09/2026 |
+| `static/js/play/screens.js:192` (`applyAnimationClip`, clip `sprite`), `static/js/play/actions.js:340` (action `jouer_animation_sprite`) | `javascript:S2486` | **Corrigé, pas seulement documenté** : `JSON.parse(custom_keyframes / data_value)` invalide laissait `spriteData` retomber silencieusement sur `{}` (aucune animation jouée) sans aucun signal — `custom_keyframes`/`data_value` sont produits par l'éditeur, jamais tapés à la main, donc un JSON invalide ici trahit presque toujours un bug côté éditeur plutôt qu'une simple erreur de saisie. Un `console.warn('configuration sprite invalide', e)` a été ajouté dans les deux `catch` : signal devtools pour le créateur en test, **comportement joueur inchangé** (l'animation reste silencieusement absente). Couvert par un nouveau test (`static/js/play/__tests__/actions.test.js`, `runActionNode — jouer_animation_sprite avec data_value JSON invalide`) qui vérifie à la fois l'absence de crash/rendu cassé ET l'appel du `console.warn`. | Lot 3 "modernisation JS", 16/09/2026 |
+
+### Détail — `javascript:S8786` (ReDoS), lot 1 "modernisation JS"
+
+Méthode : pour chaque regex distincte flaguée, construction d'entrées **adversariales** (choisies pour maximiser l'ambiguïté que Sonar soupçonne) via un script Node.js dédié, mesure du temps d'exécution à plusieurs tailles croissantes. Un vrai ReDoS montre une croissance **exponentielle** du temps avec la taille de l'entrée (doubler la taille multiplie le temps par un facteur, pas par une constante) — ici, le temps reste quasi-linéaire à toutes les tailles testées, y compris pour la structure la plus suspecte des 3.
+
+**Pattern A** — `FORGE_REF_PATTERN` (`filter-repeater-rows.js:10`) et `_FILTER_REF_RE` (`panel-init.js:254`, copie identique) :
+```
+/^\{\{\s*([^.{}]+)\.([^.{}]+)\s*\}\}$/
+```
+Structure soupçonnée : deux groupes quantifiés (`[^.{}]+`) séparés par un littéral (`\.`). Non exploitable ici car les deux classes sont **négatives** et excluent explicitement le `.` qui les sépare — à une position donnée, il n'existe qu'un seul découpage possible entre les deux groupes (pas de chevauchement combinatoire).
+Entrées testées : `` `{{` + 'a'.repeat(n) `` (pas de fermeture) et `` `{{` + 'a'.repeat(n) + '.' + 'b'.repeat(n) `` (point présent, pas de fermeture), `n` = 1 000 / 10 000 / 50 000 / 100 000.
+Résultat mesuré : **1.39 ms à n=100 000** (pire cas). Vérifié aussi que le pattern reste correct sur une entrée valide (`{{Objet.champ}}` → capture `['Objet', 'champ']`).
+
+**Pattern B** — `FORGE_VAR_REF_PATTERN` (`filter-repeater-rows.js:11`) et `_VAR_REF_RE` (`panel-init.js:261`, copie identique) :
+```
+/^\{\{\s*\$([^.{}[\]]+)((?:\.[^.{}[\]]+|\[\d+\])*)\s*\}\}$/
+```
+Structure soupçonnée : la plus proche d'un vrai ReDoS des 3 — un groupe répété par `*` dont une branche de l'alternance contient elle-même un `+` (proche du classique `(a+)*`). Non exploitable ici car chaque itération exige un caractère de tête exclusif (`.` ou `[`) qui est justement exclu de la classe négative interne (`[^.{}[\]]`) — aucune itération ne peut chevaucher la suivante.
+Entrées testées : `` `{{$a` + '.b'.repeat(n) `` (répétition simple, pas de fermeture) et `` `{{$a` + '.b[0]'.repeat(n) `` (alternance des deux branches, pas de fermeture), `n` = 1 000 / 5 000 / 10 000 / 20 000.
+Résultat mesuré : **0.95 ms à n=20 000 segments** (pire cas, forme alternée). Vérifié sur entrée valide (`{{$var.champ[0].sous}}` → capture `['var', '.champ[0].sous']`).
+
+**Pattern C** — `xapi-client.js:132` :
+```js
+config.endpoint.replace(/\/+$/, '')
+```
+Structure soupçonnée : un seul groupe quantifié sur un littéral unique, ancré en fin de chaîne — le cas le plus simple des 3, sans groupe adjacent ni alternance avec qui entrer en ambiguïté.
+Entrée testée : `'/'.repeat(n)`, `n` = 10 000 / 100 000 / 1 000 000.
+Résultat mesuré : **1.38 ms à n=1 000 000** (le run à n=100 000 a affiché 13.89 ms, un pic de bruit de mesure — non reproductible et incohérent avec un temps plus court à n=1 000 000, donc pas un signal réel). Vérifié sur entrée valide (`'https://host///'.replace(...)` → `'https://host'`).
+
+**Pour refaire ce test après une modification d'une de ces 3 regex** : `node docs/redos_probe_s8786.js` — script conservé dans le dépôt, directement exécutable, pas à reconstituer depuis la prose. Si le temps croît plus vite que linéairement (ex. ×100 quand la taille ×10), c'est un vrai ReDoS — sinon, le `NOSONAR` reste justifié.
 
 ## 6. Backlog qualité
 
 - **djLint H021 (49 occurrences, 6 templates)** — styles inline à remplacer par un système de modèles/classes CSS réutilisables. **Priorité immédiate** après la clôture de ce dispositif, avant ou après la Phase 4 CI selon décision à prendre le moment venu. Ce n'est **pas** une exception documentée en section 5 : c'est une dette assumée et non traitée, à corriger, pas à justifier indéfiniment.
-- **Code smells SonarQube (421 restants)** — analysés en volume (modernisation JS, complexité cognitive Python, duplication) mais pas encore triés catégorie par catégorie. Prochain lot après ce document.
-- **Trajectoire SonarQube CI bloquant** — une fois (a) le rapport de code smells trié et (b) une solution trouvée pour `Web:S5247` (ou acceptée comme limitation permanente), retirer `continue-on-error: true` du job `sonarqube` dans `.gitea/workflows/deploy.yml`.
+- **Code smells SonarQube (421 restants)** — lot JS "modernisation" (357 issues), plan détaillé et validé dans `docs/JS_MODERNIZATION_PLAN.md` (répartition par règle, classification mécanique/cas par cas, outillage vérifié, 9 lots) ; lots 1-3 (`S8786`, `S2703`, `S2486`) faits, lots 4-9 **en pause** — dépendent de scores Sonar exacts (voir section 2). Reste aussi la complexité cognitive Python et la duplication, non encore triées.
+- **SonarQube (local + CI/prod) retiré, à réintégrer** — job CI et service prod retirés le 18/09/2026 (voir section 2). Une fois l'accès dashboard rétabli (local et/ou prod derrière Caddy) : reconfigurer le job `.gitea/workflows/deploy.yml`/le service `docker-compose.prod.yml`, reprendre le lot JS "modernisation" au lot 4, puis retirer `continue-on-error: true` une fois le rapport de code smells trié et `Web:S5247` résolu ou accepté comme limitation permanente.
diff --git a/docker-compose.prod.yml b/docker-compose.prod.yml
index f5d7cec0..a07544de 100644
--- a/docker-compose.prod.yml
+++ b/docker-compose.prod.yml
@@ -24,46 +24,6 @@ services:
       SMTP_PASSWORD: ${SMTP_PASSWORD:-}
       SMTP_FROM: ${SMTP_FROM:-}
 
-  # SonarQube (rapport qualité — voir sonar-project.properties, CODE_QUALITY.md).
-  # Base PostgreSQL dédiée (jamais la H2 embarquée par défaut, pas adaptée
-  # en usage durable) — mêmes images que la stack locale (WSL,
-  # ~/sonarqube-stack/docker-compose.yml) pour rester cohérent.
-  # SONAR_DB_PASSWORD : requis, à définir dans le .env du serveur (jamais
-  # en dur ici) — même convention que REGISTRY_IMAGE ci-dessus.
-  # Port lié à 127.0.0.1 uniquement (jamais 0.0.0.0) : SonarQube n'est
-  # JAMAIS exposé directement sur internet, seul Caddy (sur l'hôte, voir
-  # sonar.forgebase.fr) reverse-proxy vers ce port local avec TLS
-  # (Let's Encrypt) devant.
-  sonar-postgres:
-    image: postgres:16
-    restart: unless-stopped
-    environment:
-      POSTGRES_USER: sonar
-      POSTGRES_PASSWORD: ${SONAR_DB_PASSWORD:?SONAR_DB_PASSWORD is required}
-      POSTGRES_DB: sonarqube
-    volumes:
-      - sonar_postgres_data:/var/lib/postgresql/data
-
-  sonarqube:
-    image: sonarqube:community
-    restart: unless-stopped
-    depends_on:
-      - sonar-postgres
-    environment:
-      SONAR_JDBC_URL: jdbc:postgresql://sonar-postgres:5432/sonarqube
-      SONAR_JDBC_USERNAME: sonar
-      SONAR_JDBC_PASSWORD: ${SONAR_DB_PASSWORD:?SONAR_DB_PASSWORD is required}
-    ports:
-      - "127.0.0.1:9000:9000"
-    volumes:
-      - sonarqube_data:/opt/sonarqube/data
-      - sonarqube_extensions:/opt/sonarqube/extensions
-      - sonarqube_logs:/opt/sonarqube/logs
-
 volumes:
   forge_projects:
   forge_data:
-  sonar_postgres_data:
-  sonarqube_data:
-  sonarqube_extensions:
-  sonarqube_logs:
diff --git a/docs/JS_MODERNIZATION_PLAN.md b/docs/JS_MODERNIZATION_PLAN.md
new file mode 100644
index 00000000..d88f04d0
--- /dev/null
+++ b/docs/JS_MODERNIZATION_PLAN.md
@@ -0,0 +1,134 @@
+# Plan — lot JS "modernisation" (357 issues SonarQube)
+
+Trace de la stratégie validée avant exécution — même valeur que
+`docs/SESSION_RECAP.md` pour la Phase 3 : ce document décrit le plan tel
+que discuté et confirmé, pas un compte-rendu de ce qui a déjà été fait.
+Pour l'état d'avancement réel lot par lot, voir les commits de ce
+chantier (référencés ici au fur et à mesure).
+
+Origine : rapport SonarQube local (`http://localhost:9000`), catégorie
+"code smells" JavaScript, 357 occurrences réparties sur 22 règles.
+
+## 1. Répartition exacte par règle Sonar
+
+| Règle | Nom | Occurrences |
+|---|---|---|
+| `S7773` | Number static methods preferred over globals (`parseFloat`→`Number.parseFloat`, etc.) | 119 |
+| `S6582` | Optional chaining should be preferred | 98 |
+| `S7781` | `replaceAll()` instead of `replace()` with global regex | 29 |
+| `S7761` | Data attributes via `.dataset` | 22 |
+| `S7765` | `.includes()` instead of `.indexOf()`/`.lastIndexOf()` | 19 |
+| `S3972` | Conditionals should start on new lines | 15 |
+| `S3776` | Cognitive Complexity too high | 9 |
+| `S4138` | `for-of` should be used with Iterables | 6 |
+| `S4624` | Template literals should not be nested | 6 |
+| `S2703` | Variables should be declared explicitly (var globale implicite) | 6 |
+| `S8786` | Regex non-linear backtracking (ReDoS) | 5 |
+| `S3358` | Ternary operators should not be nested | 4 |
+| `S7744` | Unnecessary fallback objects in object spread | 3 |
+| `S2486` | Exceptions should not be ignored | 3 |
+| `S6557` | `startsWith()`/`endsWith()` instead of manual check | 3 |
+| `S7721` | Function should be moved to highest possible scope | 2 |
+| `S4144` | Functions should not have identical implementations | 2 |
+| `S6653` | `Object.hasOwn()` instead of `hasOwnProperty` | 2 |
+| `S6671` | Literal used for promise rejection (pas une `Error`) | 1 |
+| `S7755` | `.at()` instead of `[…length - index]` | 1 |
+| `S7769` | Modern Math APIs (`Math.hypot` etc.) | 1 |
+| `S3735` | `void` should not be used | 1 |
+| **Total** | | **357** |
+
+## 2. Classification
+
+### Mécanique, sans risque sémantique (équivalence prouvée)
+
+| Règle | Pourquoi c'est sûr |
+|---|---|
+| `S7773` | `parseFloat`/`parseInt`/`isNaN`/`isFinite` sont des alias exacts de `Number.*` depuis ES2015 |
+| `S7781` | `replace()`→`replaceAll()` seulement quand la regex a déjà le flag `g` (précondition de la règle) |
+| `S7765` | `.indexOf(x) !== -1` ⇔ `.includes(x)` — équivalence stricte pour ce pattern |
+| `S7761` | `getAttribute('data-x')`→`.dataset.x` — mécanique si nom d'attribut statique |
+| `S7744` | Le spread de `null`/`undefined` ne lève jamais — le fallback `\|\| {}` est toujours redondant |
+| `S6557`, `S6653`, `S7755`, `S7769` | Équivalences directes, très faible volume (7 sites), pas besoin d'outil |
+| `S3972` | Pur formatage, zéro impact comportemental |
+
+### ⚠️ Correction par rapport à l'hypothèse de départ : `S6582` n'est PAS mécanique
+
+`a && a.b` et `a?.b` divergent quand `a` est une valeur **fausse mais
+définie** (`0`, `""`, `false`, `NaN`) : `a && a.b` s'arrête et renvoie
+`a`, `a?.b` continue et accède à `.b`. Une transformation aveugle peut
+changer le comportement. Malgré son volume (98, 2ᵉ plus grosse règle),
+`S6582` est traité en examen au cas par cas, pas en lot mécanique.
+
+### Nécessite un vrai examen au cas par cas
+
+| Règle | Nature | Note |
+|---|---|---|
+| `S6582` (98) | Sémantique | Voir ci-dessus — sous-lots avec vérification du type de la valeur testée |
+| `S8786` (5) | **Sécurité-adjacent** | Sites JS, distincts de l'exception Python déjà validée en Phase 3 (`auth/email_validation.py`) |
+| `S2703` (6) | **Sécurité-adjacent** | 1 seul des 6 sites déjà examiné et validé (`bindings.js:179`, `gameData`) — 5 restent à vérifier, ne pas supposer qu'ils sont identiques |
+| `S2486` (3) | **Sécurité-adjacent** | Exception avalée, peut masquer un vrai bug |
+| `S3776` (9) | Refactor réel | Pas de fix mécanique — restructuration fonction par fonction |
+| `S4624` (6), `S3358` (4) | Lisibilité | Extraction manuelle |
+| `S4138` (6) | Risque de perte de l'index | Fix proposé par un outil mais vérifié site par site avant application |
+| `S4144` (2), `S7721` (2) | Décision de conception | Dédupliquer/déplacer une fonction change la portée |
+| `S6671` (1) | Change le type de la valeur de rejet | Impact possible sur du code aval qui inspecterait `.message`/`instanceof Error` |
+| `S3735` (1) | Dépend de l'intention | À lire avant de trancher |
+
+## 3. Outillage — vérifié empiriquement
+
+- **`eslint-plugin-sonarjs`** (officiel SonarSource, 4.2.1, dernière version) : ne couvre qu'**une seule** des 22 règles avec un fixer (`S3972`) — les règles `S77xx` sont trop récentes pour cette version.
+- **`eslint-plugin-unicorn`** : dernière version (75.0.0) exige ESLint ≥10 (incompatible avec notre 8.57.1). Version retenue : **55.0.0** (exige ESLint ≥8.56.0, compatible), ajoutée en devDependency permanente. 9 règles activées dans `.eslintrc.json` avec un fixer confirmé (`fixable: 'code'` vérifié dans le code source du plugin) :
+  - `unicorn/prefer-number-properties` (S7773)
+  - `unicorn/prefer-string-replace-all` (S7781)
+  - `unicorn/prefer-dom-node-dataset` (S7761)
+  - `unicorn/prefer-includes` (S7765)
+  - `unicorn/prefer-string-starts-ends-with` (S6557)
+  - `unicorn/prefer-modern-math-apis` (S7769)
+  - `unicorn/prefer-at` (S7755)
+  - `unicorn/no-useless-fallback-in-spread` (S7744)
+  - `unicorn/no-for-loop` (S4138)
+  - Uniquement ces 9 règles activées, jamais la config `recommended` complète du plugin (qui en contient des dizaines d'autres, jamais évaluées pour ce projet) — voir `CODE_QUALITY.md` section 2.
+- **Dry-run réel** (`--fix-dry-run`) sur tout `static/js/**/*.js` avec ces 9 règles : **222 problèmes détectés, 222 avec un fix proposé.** Les comptes par règle ne correspondent pas exactement à ceux de Sonar (moteurs différents, ex. `prefer-includes` détecte 41 cas contre 19 pour `S7765` côté Sonar) — normal, la vérification finale se fait via un rescan Sonar après application, pas via le compte ESLint.
+- **`@typescript-eslint`** (candidat pour combler `S6582`) : nécessite de remplacer tout le parser JS par le parser TypeScript — écarté, trop lourd pour un projet 100% JS.
+- **`Object.hasOwn` (`S6653`, 2 sites) et `startsWith`/`endsWith` (`S6557`, 3 sites)** : aucun outil ne les a détectés dans le dry-run — 5 sites au total, correction manuelle directe.
+
+## 4. Ordre de priorité
+
+1. Sécurité-adjacent : `S8786` (5), `S2703` (6, dont 5 non-vérifiés), `S2486` (3) — 14 sites.
+2. Structure/lisibilité à risque de bug : `S3776` (9), `S4624` (6), `S3358` (4), `S4144` (2), `S7721` (2), `S6671` (1), `S3735` (1) — 25 sites.
+3. `S6582` optional chaining (98) — lot dédié à part.
+4. Modernisation mécanique via outil (`S7773`, `S7781`, `S7765`, `S7761`, `S7744`, `S3972`, `S4138` vérifié) — le plus gros volume, le moins risqué, en dernier.
+5. Reliquat manuel très faible volume (`S6557`, `S6653`, `S7755`, `S7769`) — 7 sites.
+
+## 5. Découpage en 9 lots
+
+| Lot | Contenu | Méthode |
+|---|---|---|
+| 1 | `S8786` (5) | Lecture individuelle, diff par site |
+| 2 | `S2703` (5 restants, hors `gameData` déjà validé) | Lecture individuelle — même pattern ou différent ? |
+| 3 | `S2486` (3) | Lecture individuelle |
+| 4 | `S3776` (9) | Refactor fonction par fonction |
+| 5 | `S4624` + `S3358` + `S4144` + `S7721` + `S6671` + `S3735` (16) | Groupés, petits volumes, revue individuelle |
+| 6 | `S6582` (98) | Sous-lots de ~20-25, vérification du type à chaque site |
+| 7 | `S7773`+`S7781`+`S7765`+`S7761`+`S7744`+`S3972` via `eslint-plugin-unicorn`@55.0.0 `--fix` | `--fix` en un coup, diff complet relu avant commit |
+| 8 | `S4138` (fix proposé par `no-for-loop`, vérifié un par un) | Semi-automatique |
+| 9 | `S6557`+`S6653`+`S7755`+`S7769` (7) | Manuel direct |
+
+**À chaque lot** : diff complet montré avant application, suite de tests
+JS (`node --test static/js/play/__tests__/*.test.js
+static/js/play/offline/__tests__/*.test.js
+static/js/scenes/__tests__/*.test.js`, 241 tests) après application,
+signalement immédiat de tout changement de comportement réel (pas
+seulement du style). Rescan SonarQube local après le lot 7 (le plus gros
+volume mécanique) pour confirmer la réduction réelle plutôt que de se
+fier au seul compte ESLint, puis un rescan final après le lot 9.
+
+## Note de séquencement Git
+
+Les 9 règles `unicorn/*` ont été activées dans `.eslintrc.json` (et
+`eslint-plugin-unicorn` ajouté en devDependency) **avant** que les 222
+occurrences correspondantes soient corrigées — ce qui rend `pre-commit`/
+la CI rouges sur ESLint dès maintenant si ces changements de config
+étaient commités seuls. Ces changements restent donc **non commités**
+tant que le lot 7 (la correction mécanique) n'est pas fait, pour ne
+jamais introduire un commit où le lint échouerait sur `dev`.
diff --git a/docs/SESSION_RECAP.md b/docs/SESSION_RECAP.md
new file mode 100644
index 00000000..70f029bf
--- /dev/null
+++ b/docs/SESSION_RECAP.md
@@ -0,0 +1,242 @@
+# Compte-rendu — mise en place qualité de code (2026-09-15)
+
+Compte-rendu chronologique de la session ayant mis en place le dispositif
+qualité de code du moteur (Phases 1 à 4 du plan). Documente ce qui a été
+fait, trouvé et décidé — pour savoir comment utiliser les outils au
+quotidien, voir `CODE_QUALITY.md` (à venir, Phase 5).
+
+Commits de référence : `c57420c8` (Phase 3), `2ff127f6` et `20f9398b`
+(Phase 4).
+
+## 1. Contexte et objectif
+
+Le moteur disposait déjà d'une suite de tests (591 tests Python, 241
+tests JS) mais d'aucun outillage de qualité de code, d'architecture ou de
+détection de code mort — rien n'empêchait un import circulaire, une
+fonction non typée, une variable inutilisée ou un champ de formulaire
+inaccessible d'atteindre la production. L'objectif de cette session :
+mettre en place un dispositif **strictement strict** (aucune règle
+désactivée "pour ne pas casser le build" — l'existant est corrigé pour
+satisfaire la config, jamais l'inverse), puis nettoyer l'existant pour le
+faire passer au vert, en 4 phases :
+
+1. Configuration des outils.
+2. Audit de l'existant (rapport initial).
+3. Corrections par lots (typage, sécurité, architecture, a11y, ESLint/
+   Stylelint).
+4. Intégration continue (CI) — pour que ces vérifications protègent
+   aussi un push direct ou une PR, pas seulement la machine de qui
+   committe.
+
+## 2. Outils mis en place (Phase 1)
+
+| Outil | Rôle |
+|---|---|
+| **Ruff** | Lint + formatage Python (remplace flake8/isort/black en un seul outil) |
+| **Mypy** (`--strict`) | Typage statique Python — détecte les incohérences de type avant l'exécution |
+| **Vulture** | Détection de code mort Python (fonctions/imports jamais utilisés) |
+| **Bandit** | Analyse de sécurité Python (injections, primitives cryptographiques faibles, etc.) |
+| **import-linter** | Fait respecter les couches applicatives (ex. `db/` ne doit dépendre d'aucun autre paquet du moteur) |
+| **ESLint** (`airbnb-base`) | Lint JavaScript |
+| **Stylelint** (`stylelint-config-standard`) | Lint CSS |
+| **djLint** | Lint des templates Jinja |
+| **SonarQube Community Build** | Analyse qualité/sécurité agrégée, auto-hébergée (Docker + PostgreSQL) sur `sonar.forgebase.fr` |
+| **pre-commit** | Orchestre tous les hooks ci-dessus localement, bloquant, avant chaque commit |
+
+## 3. Bilan chiffré avant/après (Phase 2-3)
+
+État final, vérifié directement à plusieurs reprises au cours de la
+session (dernière vérification avant le commit `c57420c8`) :
+
+| Outil | Résultat final |
+|---|---|
+| Ruff (lint + format) | 0 erreur |
+| Mypy `--strict` | 0 erreur sur 388 fichiers source |
+| Vulture | 0 signalement |
+| Bandit | 0 issue (23 suppressions `# nosec` documentées individuellement) |
+| import-linter | 1 contrat ("Couches applicatives Forge Engine"), respecté |
+| ESLint | 0 erreur (12 avertissements pré-existants `no-alert`, jugés acceptables) |
+| Stylelint | 0 erreur |
+| djLint | 49 erreurs H021 (styles inline) — **backlog assumé**, voir §8 |
+
+**Note de transparence** : cette session n'a pas produit de rapport
+d'audit initial formalisé et conservé (`CODE_QUALITY.md`/Phase 5 n'existe
+pas encore) — un tableau détaillé "avant/après par paquet" avec des
+comptes précis par outil n'est donc pas reconstituable après coup avec
+certitude. Ce qui a été retenu au fil de la session :
+
+- Le typage Mypy `--strict` a été déployé **paquet par paquet**, dans
+  l'ordre : `db` → `screens` → `auth` → `core` → `ai` → `routes` → puis
+  `publish`/`scripts`/`tests`/`app.py`/`build_css.py` — chaque paquet
+  validé à 0 erreur avant de passer au suivant. `routes/` était le plus
+  gros lot (366 signalements Mypy à lui seul avant correction).
+  `screens/` était le paquet le plus étendu en nombre de fichiers touchés
+  (95 fichiers dans le commit final).
+- Ruff signalait de l'ordre de 800+ erreurs cumulées (F401/F811,
+  formatage, imports) avant nettoyage, toutes résolues.
+- Un régression Vulture a été détectée et corrigée en cours de route (un
+  changement de forme d'import — groupé vs individuel — modifiait la
+  détection d'usage), traitée via `vulture_whitelist.py`.
+
+Le rapport SonarQube (voir §8), lui, a été entièrement conservé et trié
+point par point : **72 bugs**, **57 vulnérabilités**, **466 code
+smells**, **0 security hotspot**, Quality Gate **OK**.
+
+## 4. Vrais bugs trouvés et corrigés
+
+Bugs de comportement réel (pas du style), chacun vérifié dans le diff du
+commit `c57420c8` :
+
+- **`db/definitions/create_definition.py` / `delete_definition.py`** —
+  un `relation_definition_id`/`definition_id` invalide faisait planter
+  la fonction avec un `TypeError` cru (indexation d'un `None` renvoyé par
+  `get_definition`). Remplacé par un `ValueError` explicite et lisible.
+- **`db/connection.py` → `core/flask_app.py`** — inversion de dépendance
+  architecturale : `db/` (couche la plus basse) importait
+  `core.flask_app` en interne (`_install_teardown_safety_net`), en
+  violation du contrat import-linter. Extrait en
+  `install_teardown_safety_net(app)`, une fonction pure prenant l'app en
+  paramètre ; le câblage réel (l'import de `core.flask_app`) déplacé dans
+  un nouveau fichier `core/db_teardown_guard.py` (couche de câblage, qui
+  a le droit de dépendre des deux côtés).
+- **`ai/chat.py::_describe_scene_state`** — si l'écran associé à une
+  conversation IA avait été supprimé entre-temps, la fonction plantait
+  avec un `TypeError` (indexation d'un `screen` à `None`). Ajout d'une
+  exception dédiée `ScreenDeletedError`, interceptée par
+  `run_chat_turn` pour renvoyer un message clair ("Cet écran a été
+  supprimé...") plutôt qu'un crash.
+- **`routes/scenes/scene_object_geometry.py`** — condition de course :
+  l'objet de scène était relu (`get_scene_object`) **après** avoir
+  appliqué la mise à jour de géométrie, uniquement pour lire
+  `obj["scene_id"]` — si l'objet avait été supprimé entre-temps (onglet
+  concurrent), `obj` valait `None` et l'accès plantait. La vérification
+  d'existence est maintenant faite **avant** toute mise à jour, avec un
+  retour 404 propre si l'objet n'existe plus.
+- **Fuite `</script>` dans le JSON embarqué (XSS potentiel)** — 25 sites
+  Python (`routes/scenes/scene_edit_view.py` ×22,
+  `routes/play/game_play.py` ×1, `publish/build_scorm_package.py` ×2)
+  utilisaient `json.dumps(...)` brut pour embarquer des données dans un
+  bloc `<script>` — un champ texte utilisateur (nom d'écran/objet/
+  variable, texte de dialogue...) contenant littéralement `</script>`
+  aurait refermé la balise prématurément et injecté du HTML/JS non
+  échappé sur la page. Nouveau helper partagé `db.json_for_script()`
+  (`json.dumps(data).replace("</", "<\\/")`), appliqué aux 25 sites ;
+  vérifié par un test dédié (rendu strictement identique quand aucun
+  `</` n'est présent, neutralisation confirmée sinon).
+- **Fuite de handle fichier Windows (export SCORM)** —
+  `routes/publish/export_scorm.py` servait le zip exporté via
+  `send_file()` en mode passthrough, puis tentait de le supprimer
+  (`after_this_request`) pendant que Werkzeug tenait encore le fichier
+  ouvert — l'erreur (`PermissionError`) était silencieusement avalée par
+  un `contextlib.suppress(OSError)`, laissant le fichier temporaire sur
+  le disque à chaque export. Corrigé en bufferisant le zip en mémoire
+  (`io.BytesIO`) et en supprimant le fichier temporaire avant de
+  construire la réponse. Vérifié par un script de détection de fuite
+  (avant : un fichier de 7 Mo restait sur le disque après chaque export ;
+  après : aucune fuite).
+- **Bug d'isolation de tests (compte admin partagé)** — la suite de
+  tests partage un seul compte admin sur toute une session pytest ; 22
+  sites (répartis dans `test_ai_tools.py`, `test_user_assets.py`,
+  `test_scene_object_add_asset.py`) créaient un "asset" sur ce compte
+  sans le nettoyer, polluant les tests suivants. Corrigé ponctuellement
+  aux 22 sites, **puis** doublé d'une fixture `autouse=True` dans
+  `tests/conftest.py` (`_cleanup_admin_assets`) qui nettoie
+  automatiquement tout asset créé pendant un test — filet de sécurité
+  pour un futur test qui oublierait le même nettoyage manuel.
+
+## 5. Code mort supprimé
+
+Chaque suppression vérifiée par une recherche exhaustive de toute
+référence restante dans le code (pas seulement le signalement Vulture) :
+
+- `db/definitions/add_field_to_definition.py`, `delete_field.py`,
+  `rename_definition.py`, `update_field.py`
+- `db/rows/relation_options.py`, `rows_referencing.py`
+- `screens/clause_list_codec.py`
+- `screens/rendering/trigger_for.py`
+
+Pour chacun : recherche du nom de la fonction/fichier dans tout le
+dépôt (`grep` récursif) après suppression — zéro référence restante dans
+le code exécutable (au pire une mention dans un commentaire de
+documentation, sans impact fonctionnel).
+
+## 6. Décisions de configuration vs changements de code
+
+Cas où la configuration a été adaptée aux conventions réelles et déjà
+établies du projet plutôt que de réécrire massivement le code existant :
+
+| Règle désactivée/ajustée | Fichier | Raison |
+|---|---|---|
+| `selector-class-pattern`/`selector-id-pattern: null` | `.stylelintrc.json` | Le projet utilise du camelCase pour ses classes/id CSS (`.canvasElement`, `#scormProgress`...) depuis le début — `stylelint-config-standard` impose du kebab-case par défaut ; renommer aurait touché des milliers de sélecteurs et leurs usages JS/HTML pour un gain de lisibilité nul |
+| `no-descending-specificity: null` | `.stylelintrc.json` | Le CSS existant est organisé par composant/fonctionnalité, pas par ordre strict de spécificité — se conformer aurait demandé de réordonner une grande partie du fichier |
+| `no-param-reassign: "off"` | `.eslintrc.json` | Convention déjà répandue dans le code (réassignation de paramètres pour la commodité, ex. petites moulinettes sur `event`/élément) — vérifiée site par site avant de désactiver la règle plutôt que de tout réécrire |
+| `no-use-before-define` limité aux variables/classes (`functions: false`) | `.eslintrc.json` | Pattern de callback "classique" très répandu : des gestionnaires `onclick="foo()"` posés dans le HTML référencent des fonctions déclarées plus bas dans le fichier JS — le hoisting des déclarations de fonction rend ça sûr, contrairement aux variables |
+| `func-names`, `no-underscore-dangle`, `no-console`, `no-plusplus`, `no-continue`, `no-bitwise`, `guard-for-in`, `no-restricted-syntax`, `prefer-destructuring`, `consistent-return`, `no-return-assign`, `no-nested-ternary`, `no-void`, `implicit-arrow-linebreak`, `no-unused-expressions`, `no-useless-concat` : `"off"` | `.eslintrc.json` | Chacune vérifiée individuellement comme sûre pour ce code avant désactivation (style déjà cohérent dans le projet, ex. underscore-prefixed pour le "privé" par convention) |
+| `max-len` porté à 120 | `.eslintrc.json` | Convention déjà en usage dans le code Python (Ruff `line-length = 120`) — alignée côté JS plutôt que forcer un retour à 80 sur tout le dépôt |
+| `unused-imports/no-unused-vars` avec liste blanche de ~95 noms | `.eslintrc.json` | Fonctions invoquées uniquement depuis des attributs `onclick`/`onchange` inline dans les templates Jinja — invisibles pour l'analyse statique d'ESLint (qui ne lit pas le HTML), mais réellement utilisées |
+
+## 7. Intégration CI (Phase 4)
+
+`.gitea/workflows/deploy.yml` — déclenché sur chaque push (`main` et
+`dev`) :
+
+- **`lint-python`** (bloquant) — rejoue `ruff check`/`ruff format
+  --check`/`mypy .`/`vulture`/`bandit`/`lint-imports` dans une image
+  Docker jetable (mêmes commandes que `.pre-commit-config.yaml`, jamais
+  dupliquées avec des paramètres différents). `djlint` volontairement
+  exclu (backlog H021, voir §8).
+- **`lint-js`** (bloquant) — `npm run lint:js` / `npm run lint:css` dans
+  une image `node:20-slim`.
+- **`sonarqube`** (`continue-on-error: true`, non-bloquant) — scan
+  contre l'instance self-hébergée `sonar.forgebase.fr`. N'est **pas**
+  dans le `needs` de `build-and-push` : un échec ici n'affecte jamais le
+  reste du pipeline.
+- **`build-and-push`** dépend désormais de `test-python`, `test-js`,
+  `lint-python` **et** `lint-js`.
+- **`deploy`** sécurisé : le token du registre passe par
+  `--password-stdin` (jamais en argument `-p`, visible via `ps` sur le
+  serveur) ; la clé SSH privée est supprimée en fin de job
+  (`if: always()`, `rm -f` — ne peut jamais échouer même si le fichier
+  n'a jamais été créé).
+
+Premier run réel après le push de `2ff127f6` (run CI Gitea #96, commit
+`2ff127f6`) : `test-python` ✅, `test-js` ✅, `lint-python` ✅, `lint-js`
+✅, `sonarqube` ❌ (attendu — infra pas encore prête, voir §8),
+conclusion globale du run : **succès** (confirmant que le mode
+non-bloquant de `sonarqube` fonctionne bien tel que configuré).
+
+## 8. Points en suspens / backlog
+
+- **djLint H021 (styles inline, 49 occurrences sur 6 templates)** —
+  backlogué explicitement, jamais désactivé silencieusement (documenté
+  dans chaque commit qui l'a sauté via `SKIP=djlint`). **Priorité
+  immédiate après cette session**, voir §9.
+- **SonarQube en CI** — échoue actuellement (`Failed to query server
+  version`) : l'endpoint `sonar.forgebase.fr` (Caddy + Let's Encrypt)
+  n'est pas encore pleinement opérationnel côté serveur perso. Aucune
+  date communiquée pour la mise en service — à vérifier avec l'infra
+  avant de s'attendre à un scan CI qui aboutit.
+- **Rapport SonarQube — 466 code smells** — analysés en volume mais non
+  triés individuellement (contrairement aux 72 bugs et 57 vulnérabilités,
+  entièrement passés en revue point par point cette session). Lot séparé
+  à traiter après la Phase 4.
+- **Trajectoire vers un SonarQube bloquant en CI** — une fois (a) l'infra
+  serveur opérationnelle et (b) les code smells triés (faux positifs
+  documentés en `NOSONAR`, comme déjà fait pour les 72 bugs/57
+  vulnérabilités), retirer `continue-on-error: true` du job `sonarqube`
+  et l'ajouter au `needs` de `build-and-push`.
+- **Phase 5 (CODE_QUALITY.md)** — non commencée : documentation de
+  référence sur les outils et comment les utiliser au quotidien (ce
+  fichier-ci n'en tient pas lieu, voir l'introduction).
+
+## 9. Prochaines étapes
+
+**Priorité immédiate** (juste après cette session, avant ou après la
+Phase 4 selon décision à prendre le moment venu) : supprimer le style
+inline (djLint H021) au profit d'un système de modèles/classes CSS
+réutilisables, plutôt que de continuer à accumuler des exceptions sur
+cette règle.
+
+Ensuite, dans l'ordre discuté : trier les 466 code smells SonarQube,
+activer SonarQube en CI dès que l'infra serveur est prête, puis rédiger
+`CODE_QUALITY.md` (Phase 5).
diff --git a/docs/redos_probe_s8786.js b/docs/redos_probe_s8786.js
new file mode 100644
index 00000000..4a1d6c7c
--- /dev/null
+++ b/docs/redos_probe_s8786.js
@@ -0,0 +1,57 @@
+// Script de verification empirique pour les 5 sites NOSONAR javascript:S8786
+// (voir CODE_QUALITY.md, section 5) - teste les 3 regex distinctes flaguees
+// (2 sont dupliquees dans 2 fichiers chacune) contre des entrees construites
+// pour maximiser l'ambiguite que l'analyseur Sonar soupconne, a plusieurs
+// tailles croissantes. Un vrai ReDoS montrerait une croissance exponentielle
+// du temps avec la taille (x10 la taille -> beaucoup plus que x10 le temps).
+//
+// A relancer si l'une de ces 3 regex change de forme, pour confirmer que le
+// NOSONAR reste justifie plutot que de le recopier aveuglement.
+//
+// Usage : node docs/redos_probe_s8786.js
+
+function timeIt(label, fn) {
+  const start = process.hrtime.bigint();
+  const result = fn();
+  const end = process.hrtime.bigint();
+  const ms = Number(end - start) / 1e6;
+  console.log(`${label}: ${ms.toFixed(2)}ms -> match=${result !== null}`);
+  return ms;
+}
+
+console.log('=== Pattern A (filter-repeater-rows.js:10, panel-init.js:254) ===');
+const patternA = /^\{\{\s*([^.{}]+)\.([^.{}]+)\s*\}\}$/;
+for (const n of [1000, 10000, 50000, 100000]) {
+  const evil = `{{${'a'.repeat(n)}`; // pas de point, pas de fermeture
+  timeIt(`  n=${n} (pas de point, pas de fermeture)`, () => patternA.exec(evil));
+}
+for (const n of [1000, 10000, 50000, 100000]) {
+  const evil = `{{${'a'.repeat(n)}.${'b'.repeat(n)}`; // point present, pas de fermeture
+  timeIt(`  n=${n} (point present, pas de fermeture)`, () => patternA.exec(evil));
+}
+
+console.log('');
+console.log('=== Pattern B (filter-repeater-rows.js:11, panel-init.js:261) ===');
+const patternB = /^\{\{\s*\$([^.{}[\]]+)((?:\.[^.{}[\]]+|\[\d+\])*)\s*\}\}$/;
+for (const n of [1000, 5000, 10000, 20000]) {
+  const evil = `{{$a${'.b'.repeat(n)}`; // repetition simple, pas de fermeture
+  timeIt(`  n=${n} (${n} segments ".b", pas de fermeture)`, () => patternB.exec(evil));
+}
+for (const n of [1000, 5000, 10000, 20000]) {
+  const evil = `{{$a${'.b[0]'.repeat(n)}`; // alternance des deux branches
+  timeIt(`  n=${n} (${n} segments ".b[0]" alternes, pas de fermeture)`, () => patternB.exec(evil));
+}
+
+console.log('');
+console.log('=== Pattern C (xapi-client.js:132) ===');
+const patternC = /\/+$/;
+for (const n of [10000, 100000, 1000000]) {
+  const evil = '/'.repeat(n);
+  timeIt(`  n=${n} (que des slashes)`, () => patternC.exec(evil));
+}
+
+console.log('');
+console.log('=== Verification d\'equivalence (entrees valides normales, comportement inchange attendu) ===');
+console.log('A sur "{{Objet.champ}}":', patternA.exec('{{Objet.champ}}'));
+console.log('B sur "{{$var.champ[0].sous}}":', patternB.exec('{{$var.champ[0].sous}}'));
+console.log('C sur "https://host///":', 'https://host///'.replace(patternC, ''));
diff --git a/static/js/play/__tests__/actions.test.js b/static/js/play/__tests__/actions.test.js
index 80be2ed7..f6a5fe0a 100644
--- a/static/js/play/__tests__/actions.test.js
+++ b/static/js/play/__tests__/actions.test.js
@@ -11,7 +11,7 @@ global.window = global.window || {};
 global.gameData = global.gameData || {};
 const {
   resolveSpriteFrames, runSpriteAnimation, stopAllSpriteAnimations, activeSpriteAnimations,
-  applyObjectProperty, clampSceneObjectPosition,
+  applyObjectProperty, clampSceneObjectPosition, runActionNode,
 } = require('../actions.js');
 
 function fakeImg() {
@@ -147,3 +147,27 @@ test('applyObjectProperty — pos_x_relatif reste dans les limites de la scène
     assert.equal(el.style.left, '80px'); // 100 - 20, jamais au-delà
   });
 });
+
+test('runActionNode — jouer_animation_sprite avec data_value JSON invalide : avertit en console, ne casse pas le rendu (bug S2486 : exception avalée en silence auparavant)', () => {
+  const el = fakeImg();
+  const originalDocument = global.document;
+  const originalWarn = console.warn;
+  const warnCalls = [];
+  global.document = { querySelector: () => el };
+  console.warn = (...args) => { warnCalls.push(args); };
+  try {
+    const result = runActionNode({
+      action_type: 'jouer_animation_sprite',
+      target_element_id: 'obj1',
+      data_value: '{not valid json',
+    });
+    assert.ok(result instanceof Promise, 'doit quand même renvoyer une Promise, comme un data_value valide');
+    assert.equal(el.src, '', 'aucune frame ne doit être posée — rendu inchangé, pas de crash');
+    assert.equal(warnCalls.length, 1);
+    assert.match(warnCalls[0][0], /configuration sprite invalide/);
+  } finally {
+    global.document = originalDocument;
+    console.warn = originalWarn;
+    stopAllSpriteAnimations();
+  }
+});
diff --git a/static/js/play/actions.js b/static/js/play/actions.js
index edd17f22..a6c17d0e 100644
--- a/static/js/play/actions.js
+++ b/static/js/play/actions.js
@@ -330,14 +330,23 @@ function runActionNode(node) {
     // musique de fond de l'écran (runScreenBackgroundMusic() dans
     // screens.js, qui elle boucle et s'arrête au changement d'écran).
     // Fire-and-forget : ne bloque jamais la suite du graphe.
-    if (node.data_value) new Audio(node.data_value).play().catch(() => {});
+    if (node.data_value) new Audio(node.data_value).play().catch(() => {}); // NOSONAR S2486, CODE_QUALITY.md
     return Promise.resolve();
   } if (node.action_type === 'jouer_animation_sprite' && (node.target_element_id || node.target_object_id)) {
     const spriteTargetId = node.target_element_id || node.target_object_id;
     const targetEl = document.querySelector(`[data-element-id="${spriteTargetId}"]`);
     if (targetEl) {
       let spriteData = {};
-      try { spriteData = JSON.parse(node.data_value || '{}'); } catch (e) { /* data_value invalide : rien à jouer */ }
+      try {
+        spriteData = JSON.parse(node.data_value || '{}');
+      } catch (e) {
+        // Signalement devtools uniquement (voir CODE_QUALITY.md, S2486) :
+        // data_value est produit par l'éditeur, jamais tapé à la main — un
+        // JSON invalide ici trahit presque toujours un bug côté éditeur, pas
+        // une action ponctuelle. Comportement joueur inchangé : l'animation
+        // reste silencieusement absente (spriteData reste {}).
+        console.warn('configuration sprite invalide', e);
+      }
       runSpriteAnimation(targetEl, resolveSpriteFrames(spriteTargetId, spriteData));
     }
     return Promise.resolve();
diff --git a/static/js/play/offline/filter-repeater-rows.js b/static/js/play/offline/filter-repeater-rows.js
index 734b0a0b..6b1e4e4a 100644
--- a/static/js/play/offline/filter-repeater-rows.js
+++ b/static/js/play/offline/filter-repeater-rows.js
@@ -7,8 +7,8 @@
 // _compare() côté Python (chargé avant ce fichier dans templates/
 // play.html), pas de troisième copie de cette logique.
 
-const FORGE_REF_PATTERN = /^\{\{\s*([^.{}]+)\.([^.{}]+)\s*\}\}$/;
-const FORGE_VAR_REF_PATTERN = /^\{\{\s*\$([^.{}[\]]+)((?:\.[^.{}[\]]+|\[\d+\])*)\s*\}\}$/;
+const FORGE_REF_PATTERN = /^\{\{\s*([^.{}]+)\.([^.{}]+)\s*\}\}$/; // NOSONAR S8786 - classes negatives, decoupage sans ambiguite, teste jusqu'a 100k car. sans blowup (voir CODE_QUALITY.md)
+const FORGE_VAR_REF_PATTERN = /^\{\{\s*\$([^.{}[\]]+)((?:\.[^.{}[\]]+|\[\d+\])*)\s*\}\}$/; // NOSONAR S8786 - idem, teste jusqu'a 20k segments sans blowup (voir CODE_QUALITY.md)
 const FORGE_PATH_SEGMENT_RE = /\.([^.[\]]+)|\[(\d+)\]/g;
 
 // Port de decode_clauses (screens/clause_list_codec.py) — repli sur
diff --git a/static/js/play/offline/xapi-client.js b/static/js/play/offline/xapi-client.js
index 0fb0f6a0..8b639d8e 100644
--- a/static/js/play/offline/xapi-client.js
+++ b/static/js/play/offline/xapi-client.js
@@ -69,7 +69,7 @@ function forgeXapiActor() {
         return { objectType: 'Agent', name: name || id, account: { homePage: 'urn:forge-engine', name: id } };
       }
     }
-  } catch (e) { /* API SCORM présente mais qui répond mal — repli silencieux */ }
+  } catch (e) { /* API SCORM présente mais qui répond mal — repli silencieux */ } // NOSONAR S2486, CODE_QUALITY.md
   return { objectType: 'Agent', name: 'Apprenant', mbox: 'mailto:anonymous@forge-engine.local' };
 }
 
@@ -129,7 +129,7 @@ function forgeXapiSendStatement(verbId, result, object) {
     timestamp: new Date().toISOString(),
   };
   if (result) statement.result = result;
-  const endpoint = `${config.endpoint.replace(/\/+$/, '')}/statements`;
+  const endpoint = `${config.endpoint.replace(/\/+$/, '')}/statements`; // NOSONAR S8786 - un seul quantificateur sur 1 litteral, teste jusqu'a 1M car. sans blowup (voir CODE_QUALITY.md)
   try {
     fetch(endpoint, {
       method: 'POST',
diff --git a/static/js/play/screens.js b/static/js/play/screens.js
index 018b75e1..ca3cc997 100644
--- a/static/js/play/screens.js
+++ b/static/js/play/screens.js
@@ -86,7 +86,7 @@ function runScreenBackgroundMusic(screenId) {
   if (!url) return;
   currentBackgroundAudio = new Audio(url);
   currentBackgroundAudio.loop = true;
-  currentBackgroundAudio.play().catch(() => {});
+  currentBackgroundAudio.play().catch(() => {}); // NOSONAR S2486 - autoplay bloque, voir CODE_QUALITY.md
 }
 
 // Voir le commentaire sur #playFrame dans le <style> de play.html : la
@@ -189,7 +189,16 @@ function applyAnimationClip(clip) {
       // assigné, gameData.personnage_animations, pas figées au moment où
       // le clip a été configuré).
       let spriteData = {};
-      try { spriteData = JSON.parse(clip.custom_keyframes || '{}'); } catch (e) { /* invalide : rien à jouer */ }
+      try {
+        spriteData = JSON.parse(clip.custom_keyframes || '{}');
+      } catch (e) {
+        // Signalement devtools uniquement (voir CODE_QUALITY.md, S2486) :
+        // custom_keyframes est produit par l'éditeur, jamais tapé à la
+        // main — un JSON invalide ici trahit presque toujours un bug côté
+        // éditeur, pas une action ponctuelle. Comportement joueur inchangé :
+        // l'animation reste silencieusement absente (spriteData reste {}).
+        console.warn('configuration sprite invalide', e);
+      }
       spriteData.loop = infinite;
       setTimeout(() => { runSpriteAnimation(target, resolveSpriteFrames(clip.element_id, spriteData)); }, delay * 1000);
     } else {
diff --git a/static/js/scenes/__tests__/collision-rules-editor.test.js b/static/js/scenes/__tests__/collision-rules-editor.test.js
index 88b50d7c..95e45623 100644
--- a/static/js/scenes/__tests__/collision-rules-editor.test.js
+++ b/static/js/scenes/__tests__/collision-rules-editor.test.js
@@ -28,6 +28,7 @@ function makeEl() {
     getAttribute() { return null; },
     addEventListener() {},
     removeEventListener() {},
+    dataset: {},
   };
   Object.defineProperty(el, 'innerHTML', {
     get() { return this._html; },
@@ -48,6 +49,9 @@ function setupGlobals() {
   global.ELEMENT_VISIBILITY_LABELS_MAP = { visible: 'Visible' };
   global.VIDEO_MODE_LABELS_MAP = { plein_ecran: 'Plein écran' };
   global.USER_ASSETS_OPTIONS = [];
+  // Nécessaire depuis le chargement de scene-editor.js (voir plus bas) :
+  // initScenePosFields() la lit dès son propre appel top-level.
+  global.CURRENT_SELECTED_ID = null;
 
   const elementsById = {};
   global.document = {
@@ -75,6 +79,11 @@ function setupGlobals() {
 setupGlobals();
 loadAsScript('../collision-rules-editor.js');
 loadAsScript('../../triggers/trigger-editor.js');
+// scene-editor.js APRÈS trigger-editor.js, exactement l'ordre de chargement
+// réel de templates/scene_edit.html (voir CODE_QUALITY.md, S2703) —
+// nécessaire pour tester refreshSceneObjectNames() en conditions réelles,
+// contre la vraie déclaration `SCENE_OBJECT_NAMES` de trigger-editor.js.
+loadAsScript('../scene-editor.js');
 
 test('assistant — une chaîne "attendre -> puis dialogue" sauvegarde bien LES DEUX, dans le bon ordre', () => {
   // Bug corrigé : "Rien de plus" renvoyait la DERNIÈRE feuille ajoutée
@@ -212,3 +221,27 @@ test('triggerActionChainHtml — un bouton "+ Ajouter une action" apparaît apr
   assert.ok(html.includes("screenTriggerOpenAppendActionModal('a_1')"));
   assert.ok(html.includes("screenTriggerOpenAppendActionModal('d_1')"));
 });
+
+test('refreshSceneObjectNames — SCENE_OBJECT_NAMES doit rester réassignable depuis scene-editor.js (bug S2703 : déclarée en `const` dans trigger-editor.js, la réassignation levait TypeError et la liste ne se mettait jamais à jour sans recharger la page)', async () => {
+  setupGlobals();
+  global.fetch = function (url) {
+    assert.equal(url, '/game/pytest_wizard/scene-object-names');
+    return Promise.resolve({ ok: true, json: () => Promise.resolve(['Marc', 'Damien']) });
+  };
+
+  global.refreshSceneObjectNames();
+  // fetch(...).then(...).then(...) est asynchrone (2 sauts de microtâches) —
+  // laisse la file d'attente se vider avant de vérifier le résultat.
+  await new Promise((resolve) => { setTimeout(resolve, 0); });
+
+  // SCENE_OBJECT_NAMES est déclarée en `let`/`const` (pas `var`) : comme
+  // dans un vrai navigateur, cette liaison ne devient JAMAIS une propriété
+  // de l'objet global — il faut la relire via une autre exécution dans le
+  // même environnement lexical partagé (vm.runInThisContext), pas via
+  // `global.SCENE_OBJECT_NAMES` (toujours `undefined`, quel que soit le
+  // résultat réel du bug).
+  assert.deepEqual(vm.runInThisContext('SCENE_OBJECT_NAMES'), ['Marc', 'Damien']);
+  // Preuve que triggerSpeakerOptions() (trigger-editor.js) voit bien le
+  // nouveau nom SANS rechargement de page — exactement le symptôme rapporté.
+  assert.ok(global.triggerSpeakerOptions(null).includes('Damien'));
+});
diff --git a/static/js/screen_edit/panel-init.js b/static/js/screen_edit/panel-init.js
index d9bf1653..ea0b0c43 100644
--- a/static/js/screen_edit/panel-init.js
+++ b/static/js/screen_edit/panel-init.js
@@ -251,14 +251,14 @@ function bindClauseListDefinitionSelect(defSelId) {
 // d'une expression s'il les rencontrait telles quelles).
 const _FILTER_REF_OPEN = '{' + '{';
 const _FILTER_REF_CLOSE = '}' + '}';
-const _FILTER_REF_RE = /^\{\{\s*([^.{}]+)\.([^.{}]+)\s*\}\}$/;
+const _FILTER_REF_RE = /^\{\{\s*([^.{}]+)\.([^.{}]+)\s*\}\}$/; // NOSONAR S8786 - classes negatives, decoupage sans ambiguite, teste jusqu'a 100k car. sans blowup (voir CODE_QUALITY.md)
 // Une paire d'accolades doublées entourant "$nom_variable" (voir
 // _VAR_REF_PATTERN côté Python, filter_repeater_rows.py) référence une
 // variable globale — le "$" la distingue sans ambiguïté de _FILTER_REF_RE
 // ci-dessus, qui attend toujours un point ("Objet.champ"). Groupe 2 : un
 // chemin optionnel ".champ"/"[index]" (chaînable) à l'intérieur de la
 // variable, utile pour une variable "objet"/"tableau".
-const _VAR_REF_RE = /^\{\{\s*\$([^.{}[\]]+)((?:\.[^.{}[\]]+|\[\d+\])*)\s*\}\}$/;
+const _VAR_REF_RE = /^\{\{\s*\$([^.{}[\]]+)((?:\.[^.{}[\]]+|\[\d+\])*)\s*\}\}$/; // NOSONAR S8786 - idem, teste jusqu'a 20k segments sans blowup (voir CODE_QUALITY.md)
 
 function _filterValueDefinitionId(objName) {
   const opt = document.querySelector(`.filterValueObjSel option[value="${CSS.escape(objName)}"]`);
diff --git a/static/js/screen_edit/tree-panels.js b/static/js/screen_edit/tree-panels.js
index 72df57df..5d22770b 100644
--- a/static/js/screen_edit/tree-panels.js
+++ b/static/js/screen_edit/tree-panels.js
@@ -29,7 +29,7 @@ function restoreTreeCollapsedState() {
   document.querySelectorAll('.elementTree .treeNode').forEach((node) => {
     const id = node.dataset.elementId;
     let collapsed = false;
-    try { collapsed = localStorage.getItem(treeCollapseKey(id)) === '1'; } catch (e) {}
+    try { collapsed = localStorage.getItem(treeCollapseKey(id)) === '1'; } catch (e) {} // NOSONAR S2486 - lecture localStorage optionnelle (etat replie/deplie), echec sans consequence, reste "deplie" par defaut
     node.classList.toggle('collapsed', collapsed);
   });
 }
@@ -54,7 +54,7 @@ function saveFloatPanelState(key, state) {
   try {
     const current = JSON.parse(localStorage.getItem(floatPanelStateKey(key)) || '{}');
     localStorage.setItem(floatPanelStateKey(key), JSON.stringify(Object.assign(current, state)));
-  } catch (e) {}
+  } catch (e) {} // NOSONAR S2486 - localStorage optionnel, voir CODE_QUALITY.md
 }
 
 function loadFloatPanelState(key) {
@@ -159,7 +159,7 @@ if (!window.__forgeIconGalleryDragBound) {
     draggedIconClass = tile.dataset.iconClass;
     tile.classList.add('dragging');
     e.dataTransfer.effectAllowed = 'copy';
-    try { e.dataTransfer.setData('text/plain', draggedIconClass); } catch (err) {}
+    try { e.dataTransfer.setData('text/plain', draggedIconClass); } catch (err) {} // NOSONAR S2486 - setData() cosmetique HTML5 (validite du drag cross-navigateur) ; le drop lit draggedIconClass (variable JS), jamais dataTransfer.getData()
   });
 
   document.addEventListener('dragend', (e) => {
@@ -227,7 +227,7 @@ if (!window.__forgeTreeToggleBound) {
     e.stopPropagation();
     const node = btn.closest('.treeNode');
     const collapsed = node.classList.toggle('collapsed');
-    try { localStorage.setItem(treeCollapseKey(node.dataset.elementId), collapsed ? '1' : '0'); } catch (err) {}
+    try { localStorage.setItem(treeCollapseKey(node.dataset.elementId), collapsed ? '1' : '0'); } catch (err) {} // NOSONAR S2486 - ecriture localStorage optionnelle (etat replie/deplie), echec sans consequence
   });
 }
 
@@ -292,7 +292,7 @@ if (!window.__forgeTreeDragBound) {
     treeDragParentId = info.parentId;
     row.classList.add('dragging');
     e.dataTransfer.effectAllowed = 'move';
-    try { e.dataTransfer.setData('text/plain', String(info.elementId)); } catch (err) {}
+    try { e.dataTransfer.setData('text/plain', String(info.elementId)); } catch (err) {} // NOSONAR S2486 - setData() cosmetique HTML5 ; le drop lit treeDragElementId (variable JS), jamais dataTransfer.getData()
   });
 
   document.addEventListener('dragend', (e) => {
diff --git a/static/js/triggers/trigger-editor.js b/static/js/triggers/trigger-editor.js
index c9547ea0..036d878f 100644
--- a/static/js/triggers/trigger-editor.js
+++ b/static/js/triggers/trigger-editor.js
@@ -17,7 +17,16 @@
 // scene_edit.html) — N'IMPORTE QUEL objet (personnage, décor, fond), pas
 // seulement un personnage — proposés comme "qui parle" pour une réplique,
 // en plus de "Joueur" (toujours disponible, jamais un objet de scène).
-const SCENE_OBJECT_NAMES = (typeof SCENE_OBJECT_NAMES_JSON !== 'undefined') ? SCENE_OBJECT_NAMES_JSON : [];
+// `let`, pas `const` : réassignée depuis un AUTRE <script> (voir
+// refreshSceneObjectNames(), static/js/scenes/scene-editor.js) — deux
+// balises <script> classiques sur la même page partagent un même
+// environnement lexical global, mais une liaison `const` posée dans l'une
+// ne peut PAS être réassignée depuis l'autre (TypeError: Assignment to
+// constant variable., vérifié empiriquement). Bug réel trouvé lors de
+// l'audit S2703 : renommer un personnage puis ouvrir un dialogue de
+// déclencheur SANS recharger la page ne voyait jamais le nouveau nom.
+// eslint-disable-next-line prefer-const -- reassignee depuis scene-editor.js, voir commentaire ci-dessus
+let SCENE_OBJECT_NAMES = (typeof SCENE_OBJECT_NAMES_JSON !== 'undefined') ? SCENE_OBJECT_NAMES_JSON : [];
 
 // Une réplique n'a que deux COULEURS possibles (voir .questBubble-joueur/
 // .questBubble-pnj, static/style.css) même si le nom affiché est
-- 
2.54.0


From ccf836f2c59b79b7f533b62489831f9bc9218c6a Mon Sep 17 00:00:00 2001
From: william <you@example.com>
Date: Fri, 18 Sep 2026 16:38:29 +0200
Subject: [PATCH 4/4] Lot 4 modernisation JS (SonarLint) + restauration CI
 sonarqube non-bloquante

Corrige les findings SonarQube (via SonarLint IDE, fichier par fichier)
sur ~24 fichiers static/js/ : parseFloat/parseInt -> Number.*,
.replace(/x/g,y) -> .replaceAll, .indexOf() -> .includes()/.startsWith(),
getAttribute/setAttribute -> .dataset, tableaux -> Set, x && x.y -> x?.y
(verifie site par site), extraction de template litteraux imbriques,
ternaires imbriquees, refactors de complexite cognitive (S3776) via
tables de dispatch, Object.hasOwn, .at(), et deduplication de fonctions
identiques (S4144). Deux exceptions S2486 documentees/corrigees
(filter-repeater-rows.js) et un cas S2703 de partage inter-scripts
complete (_collisionWizard, trigger-editor.js <-> collision-rules-editor.js).
Details complets dans CODE_QUALITY.md section 5.

Restaure aussi le job CI "sonarqube" (non-bloquant) dans
.gitea/workflows/deploy.yml maintenant que l'instance prod est
operationnelle.

Suites vertes : 276/276 JS (node --test), 591/591 Python (pytest).

SKIP=djlint sur ce commit : hook djlint bloquant sur le backlog H021
(styles inline, 49 occurrences/6 templates) deja documente comme dette
assumee non traitee dans CODE_QUALITY.md section 6, aucun rapport avec
ce commit (aucun template touche ici) - valide explicitement avec
l'utilisateur avant de contourner ce hook.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 .gitea/workflows/deploy.yml                   |  47 +-
 CODE_QUALITY.md                               |  17 +-
 static/js/ia/ia-chat.js                       |   6 +-
 static/js/play/__tests__/actions.test.js      | 398 ++++++++++-
 .../collision-dialogue-integration.test.js    |   5 +
 .../collision-rules-controller.test.js        |  16 +-
 .../__tests__/dialogue-box-controller.test.js |  43 +-
 .../play/__tests__/quiz-box-templates.test.js |   3 +
 static/js/play/actions.js                     | 627 ++++++++++--------
 static/js/play/bindings.js                    |  62 +-
 static/js/play/collision-rules-controller.js  | 209 +++---
 static/js/play/conditions.js                  |  32 +-
 static/js/play/dialogue-box-controller.js     | 153 +++--
 .../__tests__/filter-repeater-rows.test.js    |  22 +
 .../__tests__/render-special-widgets.test.js  | 115 ++++
 static/js/play/offline/compute-operation.js   | 119 ++--
 .../js/play/offline/filter-repeater-rows.js   |  26 +-
 static/js/play/offline/render-element.js      |  34 +-
 static/js/play/offline/render-jauge.js        |  89 ++-
 static/js/play/offline/render-overlay.js      |   2 +-
 static/js/play/offline/render-repeater.js     |   8 +-
 .../js/play/offline/render-special-widgets.js |  10 +-
 static/js/play/personnage-controller.js       | 184 ++---
 static/js/play/quiz-box-templates.js          |  33 +-
 static/js/play/screen-triggers-controller.js  |   2 +-
 static/js/play/screens.js                     |  10 +-
 static/js/play/triggers.js                    |   9 +-
 static/js/scenes/collision-rules-editor.js    |  17 +-
 static/js/scenes/global-variables.js          |   2 +-
 static/js/scenes/scene-editor.js              | 112 ++--
 static/js/screen_edit/panel-init.js           |  29 +-
 static/js/screen_edit/personnage-panel.js     |   2 +-
 static/js/screen_edit/personnage-preview.js   |   4 +-
 static/js/screen_edit/tree-panels.js          |  33 +-
 static/js/triggers/trigger-editor.js          |  64 +-
 static/object_form.js                         |  14 +-
 36 files changed, 1720 insertions(+), 838 deletions(-)

diff --git a/.gitea/workflows/deploy.yml b/.gitea/workflows/deploy.yml
index 00fd3d70..39610926 100644
--- a/.gitea/workflows/deploy.yml
+++ b/.gitea/workflows/deploy.yml
@@ -4,12 +4,13 @@ on:
   push:
     branches: [main, dev]
 
-# Les jobs "test-*"/"lint-*" tournent sur CHAQUE push (main et dev) :
-# jusqu'ici aucune étape de CI n'exécutait la suite de tests ni les outils
-# qualité, rien n'empêchait un commit cassé d'atteindre la production (voir
-# l'audit qualité de la Phase 0 du plan). "build-and-push"/"deploy", eux,
-# restent réservés à main (via le filtre "if" sur gitea.ref) — un push sur
-# dev ne doit jamais redéployer la prod, seulement faire tourner tests/lint.
+# Les jobs "test-*"/"lint-*"/"sonarqube" tournent sur CHAQUE push (main et
+# dev) : jusqu'ici aucune étape de CI n'exécutait la suite de tests ni les
+# outils qualité, rien n'empêchait un commit cassé d'atteindre la
+# production (voir l'audit qualité de la Phase 0 du plan). "build-and-
+# push"/"deploy", eux, restent réservés à main (via le filtre "if" sur
+# gitea.ref) — un push sur dev ne doit jamais redéployer la prod, seulement
+# faire tourner tests/lint/sonar.
 #
 # lint-python/lint-js rejouent EXACTEMENT les hooks pre-commit locaux
 # (.pre-commit-config.yaml) mais bloquants ici dès le départ (déjà tous
@@ -17,11 +18,11 @@ on:
 # les hooks pre-commit ne protègent que la machine du committeur, jamais
 # un push direct ou une PR mergée depuis ailleurs. djlint EXCLU
 # volontairement (49 H021 "styles inline" déjà en backlog assumé, voir
-# CODE_QUALITY.md) — à ajouter ici quand ce lot sera traité.
-#
-# SonarQube (job CI + service prod) retiré pour l'instant — voir
-# CODE_QUALITY.md pour le contexte (accès instance locale/prod bloqué par
-# des soucis d'infra réseau, mis de côté volontairement).
+# CODE_QUALITY.md) — à ajouter ici quand ce lot sera traité. sonarqube,
+# lui, reste NON-BLOQUANT (continue-on-error) — remis en place le
+# 18/09/2026 une fois l'instance prod opérationnelle (voir CODE_QUALITY.md
+# pour l'historique du retrait temporaire), le temps que le rapport de
+# code smells soit entièrement trié.
 
 # Secrets à configurer dans Gitea (Paramètres du dépôt > Actions > Secrets) :
 #   REGISTRY_HOST   adresse du registre d'images (ex: gitea.exemple.com)
@@ -32,6 +33,8 @@ on:
 #   DEPLOY_USER     utilisateur SSH sur ce serveur
 #   DEPLOY_SSH_KEY  clé privée SSH (au format PEM) autorisée sur ce serveur
 #   DEPLOY_PATH     dossier sur le serveur où vit docker-compose.prod.yml (ex: /home/deploy/forge-engine)
+#   SONAR_TOKEN     jeton d'analyse SonarQube (Mon compte > Security > Generate Token
+#                   sur sonar.forgebase.fr) — jamais le mot de passe admin.
 #
 # Utilise directement docker/ssh/scp en ligne de commande plutôt que des
 # actions du marketplace, pour ne pas dépendre de la disponibilité de
@@ -131,6 +134,28 @@ jobs:
           RUN npm run lint:css
           DOCKERFILE
 
+  sonarqube:
+    runs-on: ubuntu-latest
+    # Non-bloquant pendant cette premiere periode (voir le bloc de
+    # commentaires en tete de fichier) — un echec ici n'empeche jamais
+    # build-and-push/deploy, contrairement a lint-python/lint-js.
+    continue-on-error: true
+    steps:
+      - uses: actions/checkout@v4
+      - name: Analyse SonarQube (rapport seul, non-bloquant)
+        run: |
+          # Meme neutralisation de .dockerignore que test-python : sonar-
+          # project.properties couvre aussi tests/ (sonar.tests).
+          mv .dockerignore .dockerignore.disabled-for-ci
+          docker build -f - -t forge-sonar:${{ gitea.sha }} . <<'DOCKERFILE'
+          FROM sonarsource/sonar-scanner-cli:latest
+          WORKDIR /usr/src
+          COPY . .
+          DOCKERFILE
+          docker run --rm forge-sonar:${{ gitea.sha }} \
+            -Dsonar.host.url=https://sonar.forgebase.fr \
+            -Dsonar.token=${{ secrets.SONAR_TOKEN }}
+
   build-and-push:
     needs: [test-python, test-js, lint-python, lint-js]
     if: gitea.ref == 'refs/heads/main'
diff --git a/CODE_QUALITY.md b/CODE_QUALITY.md
index c47e4a05..907252c1 100644
--- a/CODE_QUALITY.md
+++ b/CODE_QUALITY.md
@@ -81,8 +81,10 @@ ignore de fichier entier ou de règle globale — voir section 4.
 - `profile = "jinja"`, `max_line_length = 160`, `indent = 2`.
 - H021 (styles inline) : **backlog assumé, pas une exception corrigée** — voir section 6, ne pas confondre avec les vraies exceptions de la section 5.
 
-### SonarQube — retiré pour l'instant
-Le job CI `sonarqube` (`.gitea/workflows/deploy.yml`) et le service prod `sonarqube`/`sonar-postgres` (`docker-compose.prod.yml`) ont été retirés le 18/09/2026 : l'accès au dashboard (local WSL2 et prod derrière Caddy) est resté bloqué par des soucis d'infrastructure réseau (redirection de port WSL2/pare-feu Hyper-V côté local, réseau Docker partagé avec Caddy pas encore en place côté prod) sans lien avec le code du moteur — mis de côté volontairement plutôt que de continuer à bloquer sur de l'infra. Le lot "modernisation JS" (voir `docs/JS_MODERNIZATION_PLAN.md`) s'est arrêté après le lot 3 (`S2486`) pour cette même raison : les lots 4+ dépendent de scores Sonar exacts (complexité cognitive notamment) qu'aucun proxy fiable ne remplace. À reprendre une fois l'accès rétabli — voir section 6.
+### SonarQube
+- **CI (`sonar.forgebase.fr`)** : job `sonarqube` (`.gitea/workflows/deploy.yml`), scan à chaque push, **non-bloquant** (`continue-on-error: true`) le temps que le rapport soit entièrement trié. Retiré le 18/09/2026 (voir historique ci-dessous), remis en place le 18/09/2026 une fois l'instance prod confirmée opérationnelle.
+- **Service prod** (`docker-compose.prod.yml`) : reste retiré côté dépôt pour l'instant — l'instance prod opérationnelle n'est pas (encore) pilotée par ce fichier de ce côté-ci ; à réintégrer explicitement si besoin.
+- **Historique du retrait temporaire (16-18/09/2026)** : l'accès au dashboard (local WSL2 et prod derrière Caddy) était resté bloqué par des soucis d'infrastructure réseau (redirection de port WSL2/pare-feu Hyper-V côté local, réseau Docker partagé avec Caddy pas encore en place côté prod à ce moment) sans lien avec le code du moteur. Le lot "modernisation JS" (voir `docs/JS_MODERNIZATION_PLAN.md`) s'était arrêté après le lot 3 (`S2486`) pour cette même raison — les lots 4+ dépendent de scores Sonar exacts (complexité cognitive notamment) qu'aucun proxy fiable ne remplace parfaitement (le SonarLint de l'IDE a servi de solution de contournement fonctionnelle en attendant, voir lots 4 en cours directement sur les fichiers ouverts dans l'éditeur).
 
 ## 3. Lancer les checks en local
 
@@ -106,7 +108,7 @@ python -m pytest tests/ -q
 node --test static/js/play/__tests__/*.test.js static/js/play/offline/__tests__/*.test.js static/js/scenes/__tests__/*.test.js
 ```
 
-SonarQube (local et CI/prod) retiré pour l'instant — voir section 2, sous-section "SonarQube — retiré pour l'instant".
+SonarQube : voir section 2, sous-section "SonarQube" — CI restaurée (non-bloquante), instance locale toujours bloquée (voir historique dans cette même sous-section).
 
 ## 4. Procédure de justification d'une exception
 
@@ -137,15 +139,18 @@ SonarQube (local et CI/prod) retiré pour l'instant — voir section 2, sous-sec
 | `static/js/play/bindings.js:179` (`gameData = newData`) | `javascript:S2703` | Pattern volontaire de scripts globaux (pas des modules ES) : `gameData`/`screensData` sont déclarés une fois par `let` dans le `<script>` inline de `templates/play.html`, chargé avant tous les `static/js/play/*.js` (ordre séquentiel vérifié, pas de `defer`/`async`). Réassignation légitime d'une variable déjà déclarée dans un scope global partagé — déjà documenté dans `.eslintrc.json` (`"gameData": "writable"`). | Session du 16/09/2026 |
 | `static/js/play/bindings.js:180` (`screensData = gameData.screens`) | `javascript:S2703` | Même bloc, même pattern, même fichier de déclaration que `gameData` ci-dessus : `let screensData = gameData.screens;` posé dans le même `<script>` inline de `templates/play.html:145` (juste après `gameData:144`), chargé avant `bindings.js` — déjà documenté dans `.eslintrc.json` (`"screensData": "writable"`). Lot 2 "modernisation JS". | Lot 2 "modernisation JS", 16/09/2026 |
 | `static/js/scenes/scene-editor.js:214` (`CURRENT_SELECTED_ID = null`), `static/js/screen_edit/tree-panels.js:392` (`CURRENT_SELECTED_ID = selectedId \|\| null`) | `javascript:S2703` | Déclarée en **`var`** (pas `let`/`const`) dans `templates/scene_edit.html:833` (`var CURRENT_SELECTED_ID = {{ selected_id or 'null' }};`), chargé avant `tree-panels.js`/`scene-editor.js`/`trigger-editor.js`/`collision-rules-editor.js` (ordre vérifié, lignes 833/858/880/885/887/888) — un `var` de script classique attache directement à `window`, réassignable sans aucune restriction depuis n'importe quel autre `<script>` de la page (contrairement au cas `SCENE_OBJECT_NAMES` ci-dessous, qui lui était en `const`). Déjà documenté dans `.eslintrc.json` (`"CURRENT_SELECTED_ID": "writable"`). | Lot 2 "modernisation JS", 16/09/2026 |
-| `static/js/scenes/collision-rules-editor.js:78` (`let _collisionWizard = null;`) et ses réassignations, toutes dans ce même fichier | `javascript:S2703` | Déclarée ET réassignée exclusivement à l'intérieur de `collision-rules-editor.js` (aucun autre fichier n'y touche, vérifié par grep exhaustif) — Sonar la signale seulement parce que ce fichier est un script classique sans wrapper de module (comme tout `static/js/`), pas parce qu'un ordre de chargement entre fichiers serait en jeu ; c'est le cas le plus simple des 4 (état privé à un seul fichier). Déjà documenté dans `.eslintrc.json` (`"_collisionWizard": "writable"`). | Lot 2 "modernisation JS", 16/09/2026 |
+| `static/js/scenes/collision-rules-editor.js:78` (`let _collisionWizard = null;`) et ses réassignations dans ce fichier, **et** `static/js/triggers/trigger-editor.js:787,937` (`triggerOpenAppendActionModal`/`screenTriggerOpenAppendActionModal`, `_collisionWizard = { bodyEl: body };` sans mot-clé) | `javascript:S2703` | Même pattern de partage inter-scripts que `SCENE_OBJECT_NAMES` : `trigger-editor.js` réutilise TELLES QUELLES les étapes de l'assistant de `collision-rules-editor.js` (`renderCollisionWizardChainStep`/`collisionWizardBuildLeafAction`, qui ne lisent que `.bodyEl` — voir commentaire ligne 784-786 de `trigger-editor.js`) pour poser "+ Ajouter une action" sur un déclencheur déjà existant, plutôt que de dupliquer ces étapes. `trigger-editor.js` est chargé AVANT `collision-rules-editor.js` (`templates/scene_edit.html:887-888`), mais sans risque de TDZ : les deux réassignations de `trigger-editor.js` sont à l'intérieur de fonctions déclenchées par un clic utilisateur, jamais exécutées avant que `collision-rules-editor.js` (et son `let _collisionWizard = null;`) n'ait fini de se charger. Déjà documenté dans `.eslintrc.json` (`"_collisionWizard": "writable"`). | Lot 2 "modernisation JS", 16/09/2026 ; complété lot 4, 18/09/2026 |
 | `static/js/triggers/trigger-editor.js:28` (`let SCENE_OBJECT_NAMES = ...`) | `javascript:S2703` | **Bug réel trouvé et corrigé** (pas un faux positif comme les 4 sites ci-dessus) : était déclarée en `const`, alors que `refreshSceneObjectNames()` (`static/js/scenes/scene-editor.js:754-759`) la réassigne après un fetch — deux `<script>` classiques sur la même page partagent un même environnement lexical global, mais une liaison `const` posée dans l'un ne peut pas être réassignée depuis l'autre (`TypeError: Assignment to constant variable.`, reproduit empiriquement via `node:vm`). Symptôme : renommer un personnage puis ouvrir un dialogue de déclencheur sans recharger la page ne montrait jamais le nouveau nom dans "qui parle". Corrigé en `let`, couvert par un test de non-régression (`static/js/scenes/__tests__/collision-rules-editor.test.js`, test `refreshSceneObjectNames`) qui échoue avec `TypeError` sur l'ancien code et passe avec le nouveau. | Lot 2 "modernisation JS", 16/09/2026 |
 | 31 sites `\|safe` (`templates/scene_edit.html`, `templates/play.html`, `templates/auth/register_2fa.html`, `templates/onboarding/onboarding_new.html`, `templates/game_dashboard_simple.html`) | `Web:S5247` (Sonar) | **Faux positif confirmé sur le fond, mais non-supprimable techniquement pour l'instant.** 3 sous-groupes : (1) `rendered_html`/`qr_svg`/`description` — HTML déjà échappé côté Python (`html.escape()`) ou généré sans texte libre utilisateur ; (2) 25 sites `*_json` — `db.json_for_script()` échappe déjà `</script>` (voir Phase 3). Plusieurs syntaxes de suppression testées (commentaire Jinja `{# #}`, commentaire JS natif dans un `<script>`, bonne position de ligne) : **aucune ne fonctionne** avec l'analyseur Web de cette version de SonarQube. La résolution "Faux positif" via l'API est bloquée par le système de permissions de session. `sonar.issue.ignore.multicriteria` existe mais sans sélecteur de ligne (exclusion fichier entier uniquement) — écarté pour `scene_edit.html`/`play.html` (masquerait un futur `\|safe` réellement dangereux). Ces 31 sites restent visibles dans le rapport Sonar en l'état ; traités et compris, pas un point ouvert côté code. | Phase 3 + investigation du 16/09/2026 |
 | `static/js/play/offline/filter-repeater-rows.js:10,11`, `static/js/screen_edit/panel-init.js:254,261`, `static/js/play/offline/xapi-client.js:132` | `javascript:S8786` (ReDoS) | 3 regex distinctes (2 dupliquées dans 2 fichiers) testées empiriquement, aucune ne montre de backtracking super-linéaire réel — voir le détail complet juste en dessous du tableau (méthode reproductible). | Lot 1 "modernisation JS", 16/09/2026 |
+| `static/js/play/dialogue-box-controller.js` (`forgeShowQuizBox`, ligne du `void widget.offsetWidth;`) | `javascript:S3735` | Force une lecture de mise en page (reflow) AVANT de reposer la classe `is-active`, pour que l'animation CSS d'entrée du quiz rejoue même si la boîte était déjà active juste avant (2 questions à la suite) — idiome JS standard, `void` marque explicitement une expression dont seul l'EFFET DE LECTURE compte, jamais la valeur. 3 formes essayées dans l'ordre, chacune rejetée par une règle Sonar différente : `void widget.offsetWidth;` (S3735, "retirer void") → `widget.offsetWidth;` seule (S905, "expression sans effet — accepté par ESLint ici, `no-unused-expressions` est désactivé dans ce projet, mais pas par Sonar") → `const _ = widget.offsetWidth;` (S1481, "variable jamais lue — accepté par ESLint via `varsIgnorePattern: ^_$`, pas par Sonar"). Aucune forme ne satisfait Sonar sans en recréer une autre : `void` restauré (la plus lisible/idiomatique des 3, et la seule aussi acceptée par ESLint) et documenté ici plutôt que de continuer à faire tourner ce carrousel. | Lot 4 "modernisation JS", 18/09/2026 |
 | `static/js/screen_edit/tree-panels.js:32` (`restoreTreeCollapsedState`), `:57` (`saveFloatPanelState`), `:230` (sauvegarde état replié/déplié au clic) | `javascript:S2486` | Lecture/écriture `localStorage` purement cosmétique (éditeur seulement, jamais le jeu) : un échec (quota, storage désactivé) laisse au pire un panneau à sa position par défaut ou un nœud d'arborescence dans son état précédent — aucune donnée de jeu en jeu, aucun état perdu de façon irréversible. | Lot 3 "modernisation JS", 16/09/2026 |
 | `static/js/screen_edit/tree-panels.js:162` (`dragstart` galerie d'icônes), `:295` (`dragstart` arborescence) | `javascript:S2486` | `e.dataTransfer.setData(...)` sert uniquement à satisfaire l'exigence cross-navigateur de l'API HTML5 Drag (au moins un type MIME posé) — vérifié que les deux `drop` correspondants (lignes 177-182 et 320-344) lisent l'id glissé depuis une variable JS module (`draggedIconClass`/`treeDragElementId`), jamais `e.dataTransfer.getData(...)` : un échec de `setData` n'a donc aucun effet sur le comportement réel du glisser-déposer. | Lot 3 "modernisation JS", 16/09/2026 |
 | `static/js/play/offline/xapi-client.js:72` (`forgeXapiActor`) | `javascript:S2486` | API SCORM absente ou non conforme — attendu hors d'un vrai LMS (ex. prévisualisation) — repli déjà en place sur un acteur anonyme générique. Comportement déjà documenté par le commentaire du bloc. | Lot 3 "modernisation JS", 16/09/2026 |
 | `static/js/play/screens.js:89` (`runScreenBackgroundMusic`), `static/js/play/actions.js:333` (action "jouer_son") | `javascript:S2486` | `.play().catch(() => {})` — échec attendu du navigateur (lecture audio automatique bloquée tant qu'aucune interaction utilisateur n'a eu lieu), jamais une erreur applicative à signaler. | Lot 3 "modernisation JS", 16/09/2026 |
 | `static/js/play/screens.js:192` (`applyAnimationClip`, clip `sprite`), `static/js/play/actions.js:340` (action `jouer_animation_sprite`) | `javascript:S2486` | **Corrigé, pas seulement documenté** : `JSON.parse(custom_keyframes / data_value)` invalide laissait `spriteData` retomber silencieusement sur `{}` (aucune animation jouée) sans aucun signal — `custom_keyframes`/`data_value` sont produits par l'éditeur, jamais tapés à la main, donc un JSON invalide ici trahit presque toujours un bug côté éditeur plutôt qu'une simple erreur de saisie. Un `console.warn('configuration sprite invalide', e)` a été ajouté dans les deux `catch` : signal devtools pour le créateur en test, **comportement joueur inchangé** (l'animation reste silencieusement absente). Couvert par un nouveau test (`static/js/play/__tests__/actions.test.js`, `runActionNode — jouer_animation_sprite avec data_value JSON invalide`) qui vérifie à la fois l'absence de crash/rendu cassé ET l'appel du `console.warn`. | Lot 3 "modernisation JS", 16/09/2026 |
+| `static/js/play/offline/filter-repeater-rows.js:24` (`forgeDecodeClauses`) | `javascript:S2486` | **Corrigé, même patron que ci-dessus** : `_filtres_json` est un attribut rendu par le serveur, jamais tapé à la main — un JSON invalide y trahit presque toujours un bug côté éditeur/serveur. `console.warn('_filtres_json invalide, filtre ignoré', e)` ajouté, comportement inchangé (repli sur l'ancien format à 2 filtres fixes ou aucun filtre). Couvert par un nouveau test (`filter-repeater-rows.test.js`, `forgeDecodeClauses — _filtres_json invalide`). | Lot 4 "modernisation JS", 18/09/2026 |
+| `static/js/play/offline/filter-repeater-rows.js:59`, `:70` (`forgeResolveVariablePath`, JSON.parse + navigation `.champ`/`[index]`) | `javascript:S2486` | **Documenté, pas corrigé — nature différente du cas ci-dessus** : ici `rawValue` est la VALEUR ACTUELLE d'une variable de jeu (modifiable librement par n'importe quelle action "Modifier une variable"), pas une config interne à l'éditeur — un chemin qui ne correspond pas à sa forme actuelle est un cas normal et attendu (ex. variable encore à sa valeur par défaut non-JSON), déjà explicitement documenté par le commentaire de la fonction ("Ne lève jamais... même convention que côté serveur"). Un `console.warn` ici bruiterait la console à chaque usage légitime. | Lot 4 "modernisation JS", 18/09/2026 |
 
 ### Détail — `javascript:S8786` (ReDoS), lot 1 "modernisation JS"
 
@@ -180,5 +185,5 @@ Résultat mesuré : **1.38 ms à n=1 000 000** (le run à n=100 000 a affiché 1
 ## 6. Backlog qualité
 
 - **djLint H021 (49 occurrences, 6 templates)** — styles inline à remplacer par un système de modèles/classes CSS réutilisables. **Priorité immédiate** après la clôture de ce dispositif, avant ou après la Phase 4 CI selon décision à prendre le moment venu. Ce n'est **pas** une exception documentée en section 5 : c'est une dette assumée et non traitée, à corriger, pas à justifier indéfiniment.
-- **Code smells SonarQube (421 restants)** — lot JS "modernisation" (357 issues), plan détaillé et validé dans `docs/JS_MODERNIZATION_PLAN.md` (répartition par règle, classification mécanique/cas par cas, outillage vérifié, 9 lots) ; lots 1-3 (`S8786`, `S2703`, `S2486`) faits, lots 4-9 **en pause** — dépendent de scores Sonar exacts (voir section 2). Reste aussi la complexité cognitive Python et la duplication, non encore triées.
-- **SonarQube (local + CI/prod) retiré, à réintégrer** — job CI et service prod retirés le 18/09/2026 (voir section 2). Une fois l'accès dashboard rétabli (local et/ou prod derrière Caddy) : reconfigurer le job `.gitea/workflows/deploy.yml`/le service `docker-compose.prod.yml`, reprendre le lot JS "modernisation" au lot 4, puis retirer `continue-on-error: true` une fois le rapport de code smells trié et `Web:S5247` résolu ou accepté comme limitation permanente.
+- **Code smells SonarQube** — lot JS "modernisation" (357 issues d'origine), plan détaillé et validé dans `docs/JS_MODERNIZATION_PLAN.md` (répartition par règle, classification mécanique/cas par cas, outillage vérifié, 9 lots) ; lots 1-3 (`S8786`, `S2703`, `S2486`) faits. Lots 4+ repris le 18/09/2026 via SonarLint (IDE) fichier par fichier — pas de liste exhaustive centralisée pendant que le dashboard serveur restait inaccessible, donc pas de rescan global de confirmation avant que la CI `sonarqube` (voir ci-dessous) tourne à nouveau. Reste aussi la complexité cognitive Python et la duplication, non encore triées.
+- **CI `sonarqube` restaurée (18/09/2026)** — job remis en place dans `.gitea/workflows/deploy.yml` (non-bloquant) une fois l'instance prod confirmée opérationnelle. Le service `docker-compose.prod.yml` reste volontairement absent de ce dépôt (prod pilotée autrement de ce côté). Une fois le premier scan CI passé : comparer son rapport à ce qui a déjà été corrigé fichier par fichier via SonarLint, pour confirmer qu'aucun doublon/oubli, avant de retirer `continue-on-error: true`.
diff --git a/static/js/ia/ia-chat.js b/static/js/ia/ia-chat.js
index 4ff2714a..96059f26 100644
--- a/static/js/ia/ia-chat.js
+++ b/static/js/ia/ia-chat.js
@@ -106,8 +106,8 @@ function iaChatRefreshAfterTurn() {
         // dessus plutôt que de rejouer un script inline.
         const canvas = document.getElementById('canvas');
         if (canvas) {
-          const newWidth = parseFloat(canvas.style.width);
-          const newHeight = parseFloat(canvas.style.height);
+          const newWidth = Number.parseFloat(canvas.style.width);
+          const newHeight = Number.parseFloat(canvas.style.height);
           if (!Number.isNaN(newWidth)) window.SCENE_WIDTH = newWidth;
           if (!Number.isNaN(newHeight)) window.SCENE_HEIGHT = newHeight;
         }
@@ -225,7 +225,7 @@ function iaChatLoadMessages(conversationId) {
   fetch(`/game/${GAME_SLUG}/ia-conversations/${conversationId}/messages`)
     .then((r) => r.json())
     .then((messages) => {
-      if (!messages || !messages.length) {
+      if (!messages?.length) {
         log.innerHTML = iaChatEmptyStateHtml();
         return;
       }
diff --git a/static/js/play/__tests__/actions.test.js b/static/js/play/__tests__/actions.test.js
index f6a5fe0a..7aa4e7b0 100644
--- a/static/js/play/__tests__/actions.test.js
+++ b/static/js/play/__tests__/actions.test.js
@@ -11,13 +11,32 @@ global.window = global.window || {};
 global.gameData = global.gameData || {};
 const {
   resolveSpriteFrames, runSpriteAnimation, stopAllSpriteAnimations, activeSpriteAnimations,
-  applyObjectProperty, clampSceneObjectPosition, runActionNode,
+  applyElementProperty, applyObjectProperty, clampSceneObjectPosition, runActionNode,
 } = require('../actions.js');
 
 function fakeImg() {
   return { src: '' };
 }
 
+// Mock DOM minimal pour applyElementProperty() — classList/style/dataset
+// réels (Set + objet), pas juste des espions, pour pouvoir vérifier l'état
+// après coup (ex. "la classe a bien été retirée", pas seulement "la
+// méthode a été appelée").
+function fakeElement() {
+  const classes = new Set();
+  return {
+    textContent: '',
+    style: { display: '', visibility: '' },
+    dataset: {},
+    classList: {
+      add: (c) => classes.add(c),
+      remove: (c) => classes.delete(c),
+      toggle: (c) => { if (classes.has(c)) classes.delete(c); else classes.add(c); },
+      has: (c) => classes.has(c),
+    },
+  };
+}
+
 test('runSpriteAnimation — un appel répété avec la même animation ne redémarre pas', () => {
   const el = fakeImg();
   const spriteData = { frames: ['/a0.png', '/a1.png', '/a2.png'], fps: 8, loop: true };
@@ -89,6 +108,113 @@ test('resolveSpriteFrames — résout depuis gameData.personnage_animations par
 // maintenue, voir triggers.js) pouvait sortir du cadre de la scène, rien ne
 // l'empêchant. applyObjectProperty()/clampSceneObjectPosition() le bornent
 // désormais à [0, scene_width/height - sa propre taille].
+// Couverture de TOUTES les branches d'applyElementProperty() (39 -> lot 4
+// "modernisation JS", S3776) AVANT tout refactor, pour garantir que
+// l'extraction en sous-fonctions ne change aucun comportement — voir
+// CODE_QUALITY.md.
+test('applyElementProperty — "contenu" : texte littéral, null/undefined -> vidé', () => {
+  const el = fakeElement();
+  applyElementProperty(el, 'contenu', 'Bonjour');
+  assert.equal(el.textContent, 'Bonjour');
+  applyElementProperty(el, 'contenu', null);
+  assert.equal(el.textContent, '');
+});
+
+test('applyElementProperty — "surbrillance" : toggle/off/valeur par défaut (activer)', () => {
+  const el = fakeElement();
+  applyElementProperty(el, 'surbrillance', 'toggle');
+  assert.ok(el.classList.has('forgeHighlight'));
+  applyElementProperty(el, 'surbrillance', 'toggle');
+  assert.ok(!el.classList.has('forgeHighlight'));
+  applyElementProperty(el, 'surbrillance', 'on');
+  assert.ok(el.classList.has('forgeHighlight'));
+  applyElementProperty(el, 'surbrillance', 'off');
+  assert.ok(!el.classList.has('forgeHighlight'));
+});
+
+test('applyElementProperty — "desactive" : toggle/off/valeur par défaut (désactiver)', () => {
+  const el = fakeElement();
+  applyElementProperty(el, 'desactive', 'toggle');
+  assert.ok(el.classList.has('forgeDisabled'));
+  applyElementProperty(el, 'desactive', 'toggle');
+  assert.ok(!el.classList.has('forgeDisabled'));
+  applyElementProperty(el, 'desactive', 'on');
+  assert.ok(el.classList.has('forgeDisabled'));
+  applyElementProperty(el, 'desactive', 'off');
+  assert.ok(!el.classList.has('forgeDisabled'));
+});
+
+test('applyElementProperty — "visibilite" : toggle (selon état actuel), masque, invisible, valeur par défaut (visible)', () => {
+  const el = fakeElement();
+  applyElementProperty(el, 'visibilite', 'toggle');
+  assert.equal(el.style.display, 'none');
+  applyElementProperty(el, 'visibilite', 'toggle');
+  assert.equal(el.style.display, '');
+  applyElementProperty(el, 'visibilite', 'masque');
+  assert.equal(el.style.display, 'none');
+  applyElementProperty(el, 'visibilite', 'invisible');
+  assert.equal(el.style.display, '');
+  assert.equal(el.style.visibility, 'hidden');
+  applyElementProperty(el, 'visibilite', 'visible');
+  assert.equal(el.style.display, '');
+  assert.equal(el.style.visibility, '');
+});
+
+test('applyElementProperty — "orientation" : toggle/gauche/valeur par défaut (droite)', () => {
+  const el = fakeElement();
+  applyElementProperty(el, 'orientation', 'toggle');
+  assert.ok(el.classList.has('forgeFlipped'));
+  applyElementProperty(el, 'orientation', 'toggle');
+  assert.ok(!el.classList.has('forgeFlipped'));
+  applyElementProperty(el, 'orientation', 'gauche');
+  assert.ok(el.classList.has('forgeFlipped'));
+  applyElementProperty(el, 'orientation', 'droite');
+  assert.ok(!el.classList.has('forgeFlipped'));
+});
+
+test('applyElementProperty — "pos_x_relatif"/"pos_y_relatif" : ajoute au pixel/pourcentage actuel, ignore une valeur non numérique', () => {
+  const el = fakeElement();
+  el.style.left = '10%';
+  applyElementProperty(el, 'pos_x_relatif', '5');
+  assert.equal(el.style.left, '15%');
+  el.style.top = '20%';
+  applyElementProperty(el, 'pos_y_relatif', '-5');
+  assert.equal(el.style.top, '15%');
+  applyElementProperty(el, 'pos_x_relatif', 'pas-un-nombre');
+  assert.equal(el.style.left, '15%', 'valeur non numérique : aucun changement');
+});
+
+test('applyElementProperty — propriété inconnue ou valeur null/undefined : aucun effet', () => {
+  const el = fakeElement();
+  applyElementProperty(el, 'propriete_qui_n_existe_pas', 'x');
+  applyElementProperty(el, 'width', undefined);
+  applyElementProperty(el, 'width', null);
+  assert.equal(el.style.width, undefined, 'jamais touché');
+});
+
+test('applyElementProperty — valeur "a||b" (va-et-vient) : bascule à chaque appel, persiste via dataset', () => {
+  // Premier appel (dataset vide, "pas encore à la 2e valeur") -> bascule
+  // sur la SECONDE valeur (parts[1]) et mémorise l'état "à la 2e" (voir
+  // le code : atSecond=false -> next=parts[1], dataset mis à '1').
+  const el = fakeElement();
+  applyElementProperty(el, 'width', '10||90');
+  assert.equal(el.style.width, '90%');
+  assert.equal(el.dataset.togglewidth, '1');
+  applyElementProperty(el, 'width', '10||90');
+  assert.equal(el.style.width, '10%');
+  assert.equal(el.dataset.togglewidth, '0');
+  applyElementProperty(el, 'width', '10||90');
+  assert.equal(el.style.width, '90%');
+});
+
+test('applyElementProperty — valeur directe (pas de "||") : assignation simple avec suffixe', () => {
+  const el = fakeElement();
+  applyElementProperty(el, 'width', '42');
+  assert.equal(el.style.width, '42%');
+  applyElementProperty(el, 'bg_color', '#ff0000');
+  assert.equal(el.style.backgroundColor, '#ff0000');
+});
+
 function withScreensData(screenData, fn) {
   const previousScreens = global.screensData;
   const previousId = global.window.currentScreenId;
@@ -97,6 +223,276 @@ function withScreensData(screenData, fn) {
   try { fn(); } finally { global.screensData = previousScreens; global.window.currentScreenId = previousId; }
 }
 
+// Couverture de TOUTES les branches de runActionNode() (58 -> lot 4
+// "modernisation JS", S3776) AVANT tout refactor — un seul appel par
+// action_type, avec des dépendances globales (showScreen, fetch,
+// FORGE_PLAY_URLS, les fonctions forgeApply*Offline...) remplacées par
+// des espions qui enregistrent l'appel plutôt que par leur vraie
+// implémentation (déjà testée ailleurs : screens.js, apply-actions.js).
+// Objectif : garantir que l'extraction en sous-fonctions n'envoie pas le
+// mauvais argument ou n'appelle pas la mauvaise fonction — pas retester
+// le comportement de ces dépendances elles-mêmes.
+const ACTION_GLOBAL_KEYS = [
+  'showScreen', 'screenIndexById', 'applyOpenRowBindings', 'bindClicks', 'bindHoverTexts', 'bindHoverTriggers',
+  'refreshRuntimeData', 'forgeApplyDataActionOffline', 'forgeApplyVariableActionOffline',
+  'forgeApplyScoreActionOffline', 'forgeApplyStatusActionOffline', 'forgeApplyAddRowActionOffline',
+  'FORGE_PLAY_URLS', 'fetch', 'Audio',
+];
+
+// `fn` peut être async (branches qui font un vrai fetch) — restaurer les
+// globales seulement APRÈS la résolution de son résultat (via .finally()
+// sur la promesse renvoyée, pas un await bloquant ici) est obligatoire :
+// un simple `try/finally` synchrone les restaurait pendant que la chaîne
+// .then() de runActionNode tournait encore (bug rencontré en écrivant ce
+// test : "refreshRuntimeData is not a function" alors que le stub était
+// bien posé — juste déjà retiré par le moment où le .then() s'exécutait).
+// Reste appelable SANS await pour les cas synchrones (pas de changement
+// de signature pour la majorité des tests déjà écrits).
+function withActionNodeGlobals(fn) {
+  const calls = [];
+  const previous = {};
+  ACTION_GLOBAL_KEYS.forEach((key) => { previous[key] = global[key]; });
+  const previousDispatch = global.window.dispatchGameEvent;
+  const previousOffline = global.window.FORGE_OFFLINE;
+
+  global.showScreen = (id) => calls.push(['showScreen', id]);
+  global.screenIndexById = (id) => global.screensData.findIndex((s) => s.id === id);
+  global.applyOpenRowBindings = () => calls.push(['applyOpenRowBindings']);
+  global.bindClicks = () => calls.push(['bindClicks']);
+  global.bindHoverTexts = () => calls.push(['bindHoverTexts']);
+  global.bindHoverTriggers = () => calls.push(['bindHoverTriggers']);
+  global.window.dispatchGameEvent = (id) => calls.push(['dispatchGameEvent', id]);
+  global.refreshRuntimeData = () => { calls.push(['refreshRuntimeData']); return Promise.resolve('refreshed'); };
+  global.forgeApplyDataActionOffline = (gd, node) => calls.push(['forgeApplyDataActionOffline', node.id]);
+  global.forgeApplyVariableActionOffline = (gd, node) => calls.push(['forgeApplyVariableActionOffline', node.id]);
+  global.forgeApplyScoreActionOffline = (gd, node) => calls.push(['forgeApplyScoreActionOffline', node.id]);
+  global.forgeApplyStatusActionOffline = (gd, node) => calls.push(['forgeApplyStatusActionOffline', node.id]);
+  global.forgeApplyAddRowActionOffline = (gd, node) => { calls.push(['forgeApplyAddRowActionOffline', node.id]); return 4242; };
+  global.FORGE_PLAY_URLS = {
+    flowNodeRunData: '/run-data/999999',
+    flowNodeRunVariable: '/run-variable/999999',
+    flowNodeRunScore: '/run-score/999999',
+    flowNodeRunStatus: '/run-status/999999',
+    flowNodeRunAddRow: '/run-add-row/999999',
+  };
+  global.fetch = (url, opts) => {
+    calls.push(['fetch', url, (opts && opts.method) || 'GET']);
+    return Promise.resolve({ json: () => Promise.resolve({ row_id: 4343 }) });
+  };
+  global.Audio = function FakeAudio(src) {
+    calls.push(['Audio', src]);
+    return { play: () => ({ catch: () => {} }) };
+  };
+
+  const restore = () => {
+    ACTION_GLOBAL_KEYS.forEach((key) => { global[key] = previous[key]; });
+    global.window.dispatchGameEvent = previousDispatch;
+    global.window.FORGE_OFFLINE = previousOffline;
+  };
+
+  let result;
+  try {
+    result = fn(calls);
+  } catch (e) {
+    restore();
+    throw e;
+  }
+  if (result && typeof result.then === 'function') {
+    return result.finally(restore);
+  }
+  restore();
+  return result;
+}
+
+test('runActionNode — ecran_suivant : avance si un écran suivant existe, ne fait rien en fin de liste', () => {
+  withScreensData({ id: 1 }, () => {
+    global.screensData = [{ id: 1 }, { id: 2 }];
+    withActionNodeGlobals((calls) => {
+      runActionNode({ action_type: 'ecran_suivant' });
+      assert.deepEqual(calls, [['showScreen', 2]]);
+    });
+    global.window.currentScreenId = 2;
+    withActionNodeGlobals((calls) => {
+      runActionNode({ action_type: 'ecran_suivant' });
+      assert.deepEqual(calls, [], 'déjà le dernier écran : aucun changement');
+    });
+  });
+});
+
+test('runActionNode — ecran_precedent : recule si un écran précédent existe, ne fait rien en tête de liste', () => {
+  global.screensData = [{ id: 1 }, { id: 2 }];
+  global.window.currentScreenId = 2;
+  withActionNodeGlobals((calls) => {
+    runActionNode({ action_type: 'ecran_precedent' });
+    assert.deepEqual(calls, [['showScreen', 1]]);
+  });
+  global.window.currentScreenId = 1;
+  withActionNodeGlobals((calls) => {
+    runActionNode({ action_type: 'ecran_precedent' });
+    assert.deepEqual(calls, [], 'déjà le premier écran : aucun changement');
+  });
+});
+
+test('runActionNode — aller_a : montre l\'écran cible si présent, ignore sans target_screen_id', () => {
+  withActionNodeGlobals((calls) => {
+    runActionNode({ action_type: 'aller_a', target_screen_id: 7 });
+    assert.deepEqual(calls, [['showScreen', 7]]);
+  });
+  withActionNodeGlobals((calls) => {
+    runActionNode({ action_type: 'aller_a' });
+    assert.deepEqual(calls, []);
+  });
+});
+
+test('runActionNode — ouvrir_ligne : mémorise la ligne cliquée, affiche l\'écran, rebranche les écouteurs', () => {
+  global.window.lastClickedRowId = 5;
+  global.window.lastClickedDefinitionId = 9;
+  withActionNodeGlobals((calls) => {
+    runActionNode({ action_type: 'ouvrir_ligne', target_screen_id: 3 });
+    assert.deepEqual(global.window.currentOpenRow, { definitionId: 9, rowId: 5 });
+    assert.deepEqual(calls, [['showScreen', 3], ['applyOpenRowBindings'], ['bindClicks'], ['bindHoverTexts'], ['bindHoverTriggers']]);
+  });
+});
+
+test('runActionNode — modifier_element : applique la propriété sur l\'élément trouvé, ignore si absent', () => {
+  const el = fakeElement();
+  global.document = { querySelector: (sel) => (sel.includes('"5"') ? el : null) };
+  runActionNode({
+    action_type: 'modifier_element', target_element_id: 5, element_property: 'contenu', element_value: 'Salut',
+  });
+  assert.equal(el.textContent, 'Salut');
+  // Aucune erreur levée quand l'élément n'existe pas (id différent -> querySelector renvoie null).
+  runActionNode({
+    action_type: 'modifier_element', target_element_id: 999, element_property: 'contenu', element_value: 'x',
+  });
+});
+
+test('runActionNode — modifier_objet_scene : applique la propriété sur l\'objet trouvé (par target_element_id ou target_object_id)', () => {
+  const el = fakeElement();
+  el.style.width = '10%';
+  global.document = { querySelector: () => el };
+  runActionNode({
+    action_type: 'modifier_objet_scene', target_object_id: 8, element_property: 'contenu', element_value: 'Objet',
+  });
+  assert.equal(el.textContent, 'Objet');
+});
+
+test('runActionNode — declencher_evenement : notifie l\'événement personnalisé ciblé', () => {
+  withActionNodeGlobals((calls) => {
+    runActionNode({ action_type: 'declencher_evenement', target_custom_event_id: 12 });
+    assert.deepEqual(calls, [['dispatchGameEvent', 12]]);
+  });
+});
+
+test('runActionNode — activer_onglet : montre l\'élément visé, masque ses frères directs, ignore les autres', () => {
+  const elTarget = fakeElement();
+  const elSibling = fakeElement();
+  elSibling.style.display = '';
+  const els = { 1: elTarget, 2: elSibling };
+  global.document = { querySelector: (sel) => els[sel.match(/"(\d+)"/)[1]] };
+  withScreensData({
+    id: 1,
+    elements: [{ id: 1, parent_id: null }, { id: 2, parent_id: null }, { id: 3, parent_id: 99 }],
+  }, () => {
+    runActionNode({ action_type: 'activer_onglet', target_element_id: 1 });
+  });
+  assert.equal(elTarget.style.display, '');
+  assert.equal(elSibling.style.display, 'none');
+});
+
+test('runActionNode — attendre : résout après le délai (data_value en secondes), 0 si non numérique', async () => {
+  const t0 = Date.now();
+  await runActionNode({ action_type: 'attendre', data_value: '0.01' });
+  assert.ok(Date.now() - t0 >= 5, 'doit avoir réellement attendu');
+  await runActionNode({ action_type: 'attendre', data_value: 'pas-un-nombre' });
+});
+
+test('runActionNode — modifier_donnee : hors ligne délègue à forgeApplyDataActionOffline, en ligne POST vers flowNodeRunData', async () => {
+  global.window.FORGE_OFFLINE = true;
+  withActionNodeGlobals((calls) => {
+    runActionNode({ action_type: 'modifier_donnee', id: 11 });
+    assert.deepEqual(calls, [['forgeApplyDataActionOffline', 11], ['refreshRuntimeData']]);
+  });
+  global.window.FORGE_OFFLINE = false;
+  await withActionNodeGlobals(async (calls) => {
+    await runActionNode({ action_type: 'modifier_donnee', id: 999999 });
+    assert.equal(calls[0][0], 'fetch');
+    assert.equal(calls[0][1], '/run-data/999999');
+    assert.equal(calls[0][2], 'POST');
+  });
+});
+
+test('runActionNode — modifier_variable : hors ligne délègue à forgeApplyVariableActionOffline, en ligne POST vers flowNodeRunVariable', async () => {
+  global.window.FORGE_OFFLINE = true;
+  withActionNodeGlobals((calls) => {
+    runActionNode({ action_type: 'modifier_variable', id: 22 });
+    assert.deepEqual(calls, [['forgeApplyVariableActionOffline', 22], ['refreshRuntimeData']]);
+  });
+  global.window.FORGE_OFFLINE = false;
+  await withActionNodeGlobals(async (calls) => {
+    await runActionNode({ action_type: 'modifier_variable', id: 999999 });
+    assert.equal(calls[0][1], '/run-variable/999999');
+  });
+});
+
+test('runActionNode — modifier_score : hors ligne délègue à forgeApplyScoreActionOffline, en ligne POST vers flowNodeRunScore', async () => {
+  global.window.FORGE_OFFLINE = true;
+  withActionNodeGlobals((calls) => {
+    runActionNode({ action_type: 'modifier_score', id: 33 });
+    assert.deepEqual(calls, [['forgeApplyScoreActionOffline', 33], ['refreshRuntimeData']]);
+  });
+  global.window.FORGE_OFFLINE = false;
+  await withActionNodeGlobals(async (calls) => {
+    await runActionNode({ action_type: 'modifier_score', id: 999999 });
+    assert.equal(calls[0][1], '/run-score/999999');
+  });
+});
+
+test('runActionNode — definir_statut_partie : hors ligne délègue à forgeApplyStatusActionOffline, en ligne POST vers flowNodeRunStatus', async () => {
+  global.window.FORGE_OFFLINE = true;
+  withActionNodeGlobals((calls) => {
+    runActionNode({ action_type: 'definir_statut_partie', id: 44 });
+    assert.deepEqual(calls, [['forgeApplyStatusActionOffline', 44], ['refreshRuntimeData']]);
+  });
+  global.window.FORGE_OFFLINE = false;
+  await withActionNodeGlobals(async (calls) => {
+    await runActionNode({ action_type: 'definir_statut_partie', id: 999999 });
+    assert.equal(calls[0][1], '/run-status/999999');
+  });
+});
+
+test('runActionNode — ajouter_ligne : hors ligne mémorise l\'id renvoyé, en ligne POST puis mémorise json.row_id', async () => {
+  global.window.FORGE_OFFLINE = true;
+  withActionNodeGlobals((calls) => {
+    runActionNode({ action_type: 'ajouter_ligne', id: 55 });
+    assert.equal(global.window.lastInsertedRowId, 4242);
+    assert.deepEqual(calls, [['forgeApplyAddRowActionOffline', 55], ['refreshRuntimeData']]);
+  });
+  global.window.FORGE_OFFLINE = false;
+  await withActionNodeGlobals(async (calls) => {
+    await runActionNode({ action_type: 'ajouter_ligne', id: 999999 });
+    assert.equal(global.window.lastInsertedRowId, 4343);
+    assert.equal(calls[0][1], '/run-add-row/999999');
+  });
+});
+
+test('runActionNode — jouer_son : joue le fichier audio (fire-and-forget), aucun effet sans data_value', () => {
+  withActionNodeGlobals((calls) => {
+    runActionNode({ action_type: 'jouer_son', data_value: '/bip.mp3' });
+    assert.deepEqual(calls, [['Audio', '/bip.mp3']]);
+  });
+  withActionNodeGlobals((calls) => {
+    runActionNode({ action_type: 'jouer_son' });
+    assert.deepEqual(calls, []);
+  });
+});
+
+test('runActionNode — action_type inconnu (ou "rien") : ne fait rien, renvoie une Promise résolue', async () => {
+  const result = runActionNode({ action_type: 'rien' });
+  assert.ok(result instanceof Promise);
+  await result;
+});
+
 test('clampSceneObjectPosition — borne au bord droit/bas de la scène', () => {
   withScreensData({ id: 1, scene_width: 200, scene_height: 100 }, () => {
     const el = { style: { width: '40px', height: '40px' } };
diff --git a/static/js/play/__tests__/collision-dialogue-integration.test.js b/static/js/play/__tests__/collision-dialogue-integration.test.js
index 5ed4afe8..8901f149 100644
--- a/static/js/play/__tests__/collision-dialogue-integration.test.js
+++ b/static/js/play/__tests__/collision-dialogue-integration.test.js
@@ -41,6 +41,11 @@ function fakeEl(style) {
       return undefined;
     },
     getAttribute(attr) { return attr === 'data-object-id' ? this._objectId : null; },
+    // Getter (pas une valeur figée à la construction) : recalculé à
+    // chaque lecture, comme le vrai `.dataset`, puisque `_objectId` est
+    // posé APRÈS coup par les tests (voir plus bas) — un `dataset: {}`
+    // gelé au moment de fakeEl() serait toujours vide.
+    get dataset() { return { objectId: this._objectId }; },
   };
 }
 
diff --git a/static/js/play/__tests__/collision-rules-controller.test.js b/static/js/play/__tests__/collision-rules-controller.test.js
index f4c5fb75..f64639d4 100644
--- a/static/js/play/__tests__/collision-rules-controller.test.js
+++ b/static/js/play/__tests__/collision-rules-controller.test.js
@@ -35,7 +35,7 @@ function fakeParentEl() {
     appendChild(child) { children.push(child); },
     querySelector(sel) {
       const m = sel.match(/data-for-object-id="(\d+)"/);
-      return m ? children.find((c) => c._forObjectId === m[1]) : undefined;
+      return m ? children.find((c) => c.dataset.forObjectId === m[1]) : undefined;
     },
   };
 }
@@ -53,12 +53,24 @@ function fakeEl(parentEl) {
   };
 }
 
+// Un vrai `.dataset` (DOMStringMap) convertit toujours la valeur assignée
+// en chaîne — reproduit ici via un Proxy, sinon `bubble.dataset.forObjectId
+// = objectId` avec un objectId numérique (cas réel : obj.id vient de la
+// base) resterait un number, et ne correspondrait plus jamais à la
+// capture de regex (toujours une string) dans fakeParentEl.querySelector().
+function makeDataset() {
+  const store = {};
+  return new Proxy(store, {
+    set(target, key, value) { target[key] = String(value); return true; },
+  });
+}
+
 function fakeBubbleEl() {
   return {
     className: 'collisionInteractBubble',
     style: {},
     textContent: '',
-    setAttribute(name, value) { if (name === 'data-for-object-id') this._forObjectId = String(value); },
+    dataset: makeDataset(),
   };
 }
 
diff --git a/static/js/play/__tests__/dialogue-box-controller.test.js b/static/js/play/__tests__/dialogue-box-controller.test.js
index ee82cf55..fb1800c5 100644
--- a/static/js/play/__tests__/dialogue-box-controller.test.js
+++ b/static/js/play/__tests__/dialogue-box-controller.test.js
@@ -20,6 +20,24 @@ const {
   forgeQuizResultQuit,
 } = require('../dialogue-box-controller.js');
 
+// Un vrai `.dataset` (DOMStringMap) lit/écrit les MÊMES attributs qu'un
+// `getAttribute('data-foo-bar')`/`setAttribute(...)`, juste sous forme
+// camelCase (`dataset.fooBar`) — ce Proxy reflète les deux dans le MÊME
+// objet `attrs` passé en argument, pour que les mocks déjà construits par
+// clé kebab-case (ex. `{ 'data-timer-mode': 'question' }`, déjà utilisé
+// par plusieurs tests de ce fichier) continuent de marcher sans y
+// toucher, tout en exposant `.dataset` comme le vrai DOM (voir
+// dialogue-box-controller.js après le lot 4 "modernisation JS", S7761).
+function kebabDataKey(camelProp) {
+  return `data-${camelProp.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`)}`;
+}
+function makeDatasetFromAttrs(attrs) {
+  return new Proxy({}, {
+    get(_, prop) { return attrs[kebabDataKey(prop)]; },
+    set(_, prop, value) { attrs[kebabDataKey(prop)] = String(value); return true; },
+  });
+}
+
 function fakeWidget(objectId) {
   const roles = {
     header: { textContent: '' },
@@ -27,8 +45,10 @@ function fakeWidget(objectId) {
     footer: { innerHTML: '' },
   };
   const classes = new Set();
+  const attrs = { 'data-object-id': String(objectId) };
   return {
-    getAttribute: (attr) => (attr === 'data-object-id' ? String(objectId) : null),
+    getAttribute: (attr) => (attr in attrs ? attrs[attr] : null),
+    dataset: makeDatasetFromAttrs(attrs),
     classList: {
       add: (c) => classes.add(c),
       remove: (c) => classes.delete(c),
@@ -57,7 +77,7 @@ function fakeWidget(objectId) {
 // couvrir le VRAI viewport qu'en s'échappant de ce conteneur, comme
 // static/js/play/video-overlay.js le fait déjà pour son propre overlay.
 test('forgeEscapeCameraForFullscreen déplace le widget en enfant de <body> et retient l\'écran d\'origine', () => {
-  const screenEl = { getAttribute: (attr) => (attr === 'data-screen-id' ? '7' : null) };
+  const screenEl = { dataset: { screenId: '7' } };
   const attrs = {};
   const classes = new Set();
   const bodyChildren = [];
@@ -65,7 +85,7 @@ test('forgeEscapeCameraForFullscreen déplace le widget en enfant de <body> et r
   const widget = {
     parentNode: null,
     closest: (sel) => (sel === '.playScreen' ? screenEl : null),
-    setAttribute: (k, v) => { attrs[k] = v; },
+    dataset: makeDatasetFromAttrs(attrs),
     classList: { add: (c) => classes.add(c) },
   };
   const previousDoc = global.document;
@@ -74,7 +94,7 @@ test('forgeEscapeCameraForFullscreen déplace le widget en enfant de <body> et r
     forgeEscapeCameraForFullscreen(widget);
     assert.equal(bodyChildren[0], widget);
     assert.equal(widget.parentNode, body);
-    assert.equal(attrs['data-owner-screen-id'], '7');
+    assert.equal(widget.dataset.ownerScreenId, '7');
     assert.equal(classes.has('quizBoxWidget--detachedForFullscreen'), true);
   } finally { global.document = previousDoc; }
 });
@@ -288,6 +308,7 @@ function fakeQuizChoiceBtn() {
 
 function fakeQuizWidget(objectId, choiceCount, attrs) {
   attrs = attrs || {};
+  attrs['data-object-id'] = String(objectId);
   const roles = {
     header: { textContent: '' },
     question: { textContent: '' },
@@ -312,13 +333,10 @@ function fakeQuizWidget(objectId, choiceCount, attrs) {
     // Simule ".closest('.playScreen')" (voir forgeEscapeCameraForFullscreen) :
     // un widget "posé sur l'écran courant" est toujours, au départ,
     // l'enfant d'un ".playScreen" fictif portant le même id d'écran.
-    closest: (sel) => (sel === '.playScreen' ? { getAttribute: (a) => (a === 'data-screen-id' ? String(window.currentScreenId) : null) } : null),
-    getAttribute: (attr) => {
-      if (attr === 'data-object-id') return String(objectId);
-      if (attr in attrs) return attrs[attr];
-      return null;
-    },
+    closest: (sel) => (sel === '.playScreen' ? { dataset: { screenId: String(window.currentScreenId) } } : null),
+    getAttribute: (attr) => (attr in attrs ? attrs[attr] : null),
     setAttribute: (k, v) => { attrs[k] = v; },
+    dataset: makeDatasetFromAttrs(attrs),
     classList: {
       // Variadique (comme le vrai DOMTokenList.remove/add) : le moteur
       // appelle parfois .remove('is-active', 'is-fullscreen') d'un coup
@@ -600,7 +618,6 @@ test('"Continuer →" est TOUJOURS présent dès la question (désactivé), jama
 
 test('une ligne "question" est affichée dans la boîte à QUIZ (header = nom de l\'objet déclencheur, corps = question+choix), pas la boîte de dialogue', () => {
   const dialogueWidget = fakeWidget(42);
-  dialogueWidget.getAttribute = (attr) => (attr === 'data-object-id' ? '42' : null);
   const quizWidget = fakeQuizWidget(99, 2);
   const previousDoc = global.document;
   global.document = docWithDialogueAndQuiz(dialogueWidget, quizWidget);
@@ -948,7 +965,7 @@ test('forgeSyncAllDialoguesCompletionToScorm propage reussi/echoue (pas juste "t
 test('répondre à une question notifie xAPI avec la bonne/mauvaise réponse et le score gagné', () => {
   const dialogueWidget = fakeWidget(42);
   const quizWidget = {
-    getAttribute: (attr) => (attr === 'data-object-id' ? '99' : null),
+    dataset: { objectId: '99' },
     classList: { add: () => {}, remove: () => {}, toggle: () => {} },
     querySelector: (sel) => (sel.indexOf('choices') !== -1 ? { innerHTML: '' } : { textContent: '' }),
     querySelectorAll: () => [],
@@ -979,7 +996,7 @@ test('répondre à une question notifie xAPI avec la bonne/mauvaise réponse et
 test('répondre à une question notifie AUSSI le SCORM 2004 (cmi.interactions.n.*, indépendant de xAPI)', () => {
   const dialogueWidget = fakeWidget(42);
   const quizWidget = {
-    getAttribute: (attr) => (attr === 'data-object-id' ? '99' : null),
+    dataset: { objectId: '99' },
     classList: { add: () => {}, remove: () => {}, toggle: () => {} },
     querySelector: (sel) => (sel.indexOf('choices') !== -1 ? { innerHTML: '' } : { textContent: '' }),
     querySelectorAll: () => [],
diff --git a/static/js/play/__tests__/quiz-box-templates.test.js b/static/js/play/__tests__/quiz-box-templates.test.js
index c4afa9e9..70c8cc24 100644
--- a/static/js/play/__tests__/quiz-box-templates.test.js
+++ b/static/js/play/__tests__/quiz-box-templates.test.js
@@ -34,6 +34,7 @@ function fakeMangaWidget() {
   const classes = new Set();
   return {
     getAttribute(attr) { return attr === 'data-object-id' ? '42' : null; },
+    dataset: { objectId: '42' },
     querySelector(sel) {
       if (sel === '[data-quiz-role="header"]') return header;
       if (sel === '[data-manga-role="progress"]') return progress;
@@ -139,6 +140,7 @@ function fakeClassiqueWidget() {
   const progress = { innerHTML: '' };
   return {
     getAttribute(attr) { return attr === 'data-object-id' ? '42' : null; },
+    dataset: { objectId: '42' },
     querySelector(sel) {
       if (sel === '[data-quiz-role="header"]') return header;
       if (sel === '[data-classique-role="progress"]') return progress;
@@ -182,6 +184,7 @@ function fakeClassiqueWidgetForResult() {
   const headerTitle = { textContent: 'Formation Sécurité Incendie' };
   return {
     getAttribute(attr) { return attr === 'data-object-id' ? '42' : null; },
+    dataset: { objectId: '42' },
     querySelector(sel) {
       if (sel === '.classiqueContent') return content;
       if (sel === '[data-classique-role="result"]') return resultZone;
diff --git a/static/js/play/actions.js b/static/js/play/actions.js
index a6c17d0e..b10af57e 100644
--- a/static/js/play/actions.js
+++ b/static/js/play/actions.js
@@ -20,104 +20,130 @@ const ELEMENT_PROPERTY_CSS = {
   pos_y: { css: 'top', suffix: '%' },
 };
 
+// Voir ELEMENT_ACTION_PROPERTIES ("contenu") : texte littéral, pas de
+// binding vers un champ d'objet ici (contrairement à
+// applyOpenRowBindings, propre à "Ouvrir la ligne cliquée"). Comme pour
+// les autres réglages ci-dessous, cible n'importe quel élément — pointer
+// ceci vers un conteneur remplacerait tout son contenu imbriqué, à éviter.
+function applyContenuProperty(targetEl, value) {
+  targetEl.textContent = value == null ? '' : value;
+}
+
+// 3.3 (Confort) — surbrillance générique dynamique : un liseré qui
+// clignote (voir la classe .forgeHighlight et son animation dans le
+// <style> de play.html), applicable à N'IMPORTE QUEL élément sans poser
+// de bordure colorée togglée à la main — utile pour un mentor qui attire
+// l'attention du joueur vers l'élément à toucher ensuite.
+function applySurbrillanceProperty(targetEl, value) {
+  if (value === 'toggle') {
+    targetEl.classList.toggle('forgeHighlight');
+  } else if (value === 'off') {
+    targetEl.classList.remove('forgeHighlight');
+  } else {
+    targetEl.classList.add('forgeHighlight');
+  }
+}
+
+// 3.5 (Confort) — verrouillage d'un élément après décision : DISTINCT de
+// "invisible" (l'élément reste visible, mais grisé et inerte —
+// pointer-events:none bloque aussi le clic, donc le déclencheur "Au clic"
+// éventuellement posé sur cet élément ne se redéclenche plus).
+function applyDesactiveProperty(targetEl, value) {
+  if (value === 'toggle') {
+    targetEl.classList.toggle('forgeDisabled');
+  } else if (value === 'off') {
+    targetEl.classList.remove('forgeDisabled');
+  } else {
+    targetEl.classList.add('forgeDisabled');
+  }
+}
+
+function applyVisibiliteProperty(targetEl, value) {
+  if (value === 'toggle') {
+    const hidden = targetEl.style.display === 'none';
+    targetEl.style.display = hidden ? '' : 'none';
+    targetEl.style.visibility = '';
+  } else if (value === 'masque') {
+    targetEl.style.display = 'none';
+  } else if (value === 'invisible') {
+    targetEl.style.display = '';
+    targetEl.style.visibility = 'hidden';
+  } else {
+    targetEl.style.display = '';
+    targetEl.style.visibility = '';
+  }
+}
+
+// Phase 7 — retourne le personnage en miroir (voir .forgeFlipped dans
+// play.html) plutôt que de nécessiter une 2e feuille de sprites "vue de
+// dos" pour chaque sens de déplacement.
+function applyOrientationProperty(targetEl, value) {
+  if (value === 'toggle') {
+    targetEl.classList.toggle('forgeFlipped');
+  } else if (value === 'gauche') {
+    targetEl.classList.add('forgeFlipped');
+  } else {
+    targetEl.classList.remove('forgeFlipped');
+  }
+}
+
+// Phase 5 — AJOUTE la valeur à la position actuelle plutôt que de
+// l'écraser (contrairement à pos_x/pos_y, "absolus") : combiné à un
+// déclencheur clavier (Phase 3), ça permet un personnage/objet qui se
+// déplace pas à pas à chaque appui de touche plutôt que de sauter
+// toujours au même endroit.
+function applyRelativePositionProperty(targetEl, property, value) {
+  const relSpec = ELEMENT_PROPERTY_CSS[property === 'pos_x_relatif' ? 'pos_x' : 'pos_y'];
+  const delta = Number.parseFloat(value);
+  if (Number.isNaN(delta)) return;
+  const current = Number.parseFloat(targetEl.style[relSpec.css]) || 0;
+  targetEl.style[relSpec.css] = (current + delta) + relSpec.suffix;
+}
+
+// "valeur1||valeur2" : effet va-et-vient — un état par élément et par
+// propriété, mémorisé directement sur le nœud DOM (data-toggle-<prop>) :
+// un clic passe à la 2e valeur, le clic suivant revient à la 1re, et
+// ainsi de suite. Ce n'est PAS enregistré en base : l'état repart de la
+// 1re valeur si l'écran est rechargé.
+function applyToggleValueProperty(targetEl, property, spec, parts) {
+  const key = `toggle${property}`;
+  const atSecond = targetEl.dataset[key] === '1';
+  const next = atSecond ? parts[0] : parts[1];
+  targetEl.style[spec.css] = next + spec.suffix;
+  targetEl.dataset[key] = atSecond ? '0' : '1';
+}
+
 function applyElementProperty(targetEl, property, value) {
   if (property === 'contenu') {
-    // Voir ELEMENT_ACTION_PROPERTIES ("contenu") : texte littéral, pas de
-    // binding vers un champ d'objet ici (contrairement à
-    // applyOpenRowBindings, propre à "Ouvrir la ligne cliquée"). Comme
-    // pour les autres réglages ci-dessous, cible n'importe quel élément —
-    // pointer ceci vers un conteneur remplacerait tout son contenu
-    // imbriqué, à éviter.
-    targetEl.textContent = value == null ? '' : value;
+    applyContenuProperty(targetEl, value);
     return;
   }
   if (property === 'surbrillance') {
-    // 3.3 (Confort) — surbrillance générique dynamique : un liseré qui
-    // clignote (voir la classe .forgeHighlight et son animation dans le
-    // <style> de play.html), applicable à N'IMPORTE QUEL élément sans
-    // poser de bordure colorée togglée à la main — utile pour un mentor
-    // qui attire l'attention du joueur vers l'élément à toucher ensuite.
-    if (value === 'toggle') {
-      targetEl.classList.toggle('forgeHighlight');
-    } else if (value === 'off') {
-      targetEl.classList.remove('forgeHighlight');
-    } else {
-      targetEl.classList.add('forgeHighlight');
-    }
+    applySurbrillanceProperty(targetEl, value);
     return;
   }
   if (property === 'desactive') {
-    // 3.5 (Confort) — verrouillage d'un élément après décision : DISTINCT
-    // de "invisible" (l'élément reste visible, mais grisé et inerte —
-    // pointer-events:none bloque aussi le clic, donc le déclencheur "Au
-    // clic" éventuellement posé sur cet élément ne se redéclenche plus).
-    if (value === 'toggle') {
-      targetEl.classList.toggle('forgeDisabled');
-    } else if (value === 'off') {
-      targetEl.classList.remove('forgeDisabled');
-    } else {
-      targetEl.classList.add('forgeDisabled');
-    }
+    applyDesactiveProperty(targetEl, value);
     return;
   }
   if (property === 'visibilite') {
-    if (value === 'toggle') {
-      const hidden = targetEl.style.display === 'none';
-      targetEl.style.display = hidden ? '' : 'none';
-      targetEl.style.visibility = '';
-    } else if (value === 'masque') {
-      targetEl.style.display = 'none';
-    } else if (value === 'invisible') {
-      targetEl.style.display = '';
-      targetEl.style.visibility = 'hidden';
-    } else {
-      targetEl.style.display = '';
-      targetEl.style.visibility = '';
-    }
+    applyVisibiliteProperty(targetEl, value);
     return;
   }
   if (property === 'orientation') {
-    // Phase 7 — retourne le personnage en miroir (voir .forgeFlipped dans
-    // play.html) plutôt que de nécessiter une 2e feuille de sprites "vue
-    // de dos" pour chaque sens de déplacement.
-    if (value === 'toggle') {
-      targetEl.classList.toggle('forgeFlipped');
-    } else if (value === 'gauche') {
-      targetEl.classList.add('forgeFlipped');
-    } else {
-      targetEl.classList.remove('forgeFlipped');
-    }
+    applyOrientationProperty(targetEl, value);
     return;
   }
   if (property === 'pos_x_relatif' || property === 'pos_y_relatif') {
-    // Phase 5 — AJOUTE la valeur à la position actuelle plutôt que de
-    // l'écraser (contrairement à pos_x/pos_y, "absolus") : combiné à un
-    // déclencheur clavier (Phase 3), ça permet un personnage/objet qui se
-    // déplace pas à pas à chaque appui de touche plutôt que de sauter
-    // toujours au même endroit.
-    const relSpec = ELEMENT_PROPERTY_CSS[property === 'pos_x_relatif' ? 'pos_x' : 'pos_y'];
-    const delta = parseFloat(value);
-    if (Number.isNaN(delta)) return;
-    const current = parseFloat(targetEl.style[relSpec.css]) || 0;
-    targetEl.style[relSpec.css] = (current + delta) + relSpec.suffix;
+    applyRelativePositionProperty(targetEl, property, value);
     return;
   }
 
   const spec = ELEMENT_PROPERTY_CSS[property];
   if (!spec || value === undefined || value === null) return;
 
-  // "valeur1||valeur2" : effet va-et-vient — un état par élément et par
-  // propriété, mémorisé directement sur le nœud DOM (data-toggle-<prop>) :
-  // un clic passe à la 2e valeur, le clic suivant revient à la 1re, et
-  // ainsi de suite. Ce n'est PAS enregistré en base : l'état repart de la
-  // 1re valeur si l'écran est rechargé.
-  if (typeof value === 'string' && value.indexOf('||') !== -1) {
-    const parts = value.split('||');
-    const key = `toggle${property}`;
-    const atSecond = targetEl.dataset[key] === '1';
-    const next = atSecond ? parts[0] : parts[1];
-    targetEl.style[spec.css] = next + spec.suffix;
-    targetEl.dataset[key] = atSecond ? '0' : '1';
+  if (typeof value === 'string' && value.includes('||')) {
+    applyToggleValueProperty(targetEl, property, spec, value.split('||'));
     return;
   }
 
@@ -138,8 +164,8 @@ function applyElementProperty(targetEl, property, value) {
 // risquer un blocage à 0.
 function clampSceneObjectPosition(targetEl, css, rawValue) {
   const screenData = screensData.find((s) => s.id === window.currentScreenId);
-  if (!screenData || screenData.scene_width == null) return rawValue;
-  const size = parseFloat(targetEl.style[css === 'left' ? 'width' : 'height']) || 0;
+  if (screenData?.scene_width == null) return rawValue;
+  const size = Number.parseFloat(targetEl.style[css === 'left' ? 'width' : 'height']) || 0;
   const boundWidth = screenData.world_width != null ? screenData.world_width : screenData.scene_width;
   const boundHeight = screenData.world_height != null ? screenData.world_height : screenData.scene_height;
   const max = (css === 'left' ? boundWidth : boundHeight) - size;
@@ -155,206 +181,278 @@ function clampSceneObjectPosition(targetEl, css, rawValue) {
 function applyObjectProperty(targetEl, property, value) {
   if (property === 'pos_x_relatif' || property === 'pos_y_relatif') {
     const css = property === 'pos_x_relatif' ? 'left' : 'top';
-    const delta = parseFloat(value);
+    const delta = Number.parseFloat(value);
     if (Number.isNaN(delta)) return;
-    const current = parseFloat(targetEl.style[css]) || 0;
+    const current = Number.parseFloat(targetEl.style[css]) || 0;
     targetEl.style[css] = `${clampSceneObjectPosition(targetEl, css, current + delta)}px`;
     return;
   }
   if (property === 'pos_x' || property === 'pos_y') {
     if (value === undefined || value === null) return;
     const css = property === 'pos_x' ? 'left' : 'top';
-    targetEl.style[css] = `${clampSceneObjectPosition(targetEl, css, parseFloat(value) || 0)}px`;
+    targetEl.style[css] = `${clampSceneObjectPosition(targetEl, css, Number.parseFloat(value) || 0)}px`;
     return;
   }
   applyElementProperty(targetEl, property, value);
 }
 
-function runActionNode(node) {
-  if (node.action_type === 'ecran_suivant') {
-    const idx = screenIndexById(window.currentScreenId);
-    if (idx > -1 && idx < screensData.length - 1) showScreen(screensData[idx + 1].id);
-    return Promise.resolve();
-  } if (node.action_type === 'ecran_precedent') {
-    const idx = screenIndexById(window.currentScreenId);
-    if (idx > 0) showScreen(screensData[idx - 1].id);
-    return Promise.resolve();
-  } if (node.action_type === 'aller_a' && node.target_screen_id) {
-    showScreen(node.target_screen_id);
-    return Promise.resolve();
-  } if (node.action_type === 'ouvrir_ligne' && node.target_screen_id) {
-    // Mémorise QUELLE ligne a été cliquée juste avant d'exécuter cette
-    // action (voir bindClicks dans triggers.js) puis affiche l'écran de
-    // détail avec ses placeholders "champ" résolus contre cette ligne
-    // précise.
-    if (window.lastClickedRowId != null && window.lastClickedDefinitionId != null) {
-      window.currentOpenRow = { definitionId: window.lastClickedDefinitionId, rowId: window.lastClickedRowId };
-    }
-    showScreen(node.target_screen_id);
-    applyOpenRowBindings();
-    // Si l'élément "ouvert" (ou un ancêtre commun avec lui) contient AUSSI
-    // un Répéteur — ex. un panneau de détail posé à côté d'une liste dans
-    // le même conteneur — applyOpenRowBindings() vient de régénérer son
-    // sous-arbre, lignes du Répéteur comprises, avec des nœuds tout neufs
-    // SANS AUCUN écouteur de clic (voir bindClicks : le garde-fou anti-
-    // doublon repose sur elDiv.dataset.clickBound, absent sur un nœud
-    // fraîchement créé). Sans ce rappel, un clic sur "ouvrir la ligne
-    // cliquée" combiné à un Répéteur sur le même écran rendait TOUTES les
-    // lignes muettes dès le clic suivant, sans la moindre erreur.
-    bindClicks();
-    bindHoverTexts();
-    bindHoverTriggers();
-    return Promise.resolve();
-  } if (node.action_type === 'modifier_element' && node.target_element_id) {
-    const targetEl = document.querySelector(`[data-element-id="${node.target_element_id}"]`);
-    if (targetEl) applyElementProperty(targetEl, node.element_property, node.element_value);
-    return Promise.resolve();
-  } if (node.action_type === 'modifier_objet_scene' && (node.target_element_id || node.target_object_id)) {
-    // Fondations multi-éditeurs — éditeur de scène 2D : équivalent de
-    // "modifier_element" ci-dessus, mais en pixels (voir
-    // applyObjectProperty() plus bas) plutôt qu'en %. data-element-id
-    // est posé sur CHAQUE objet de scène en plus de data-object-id (voir
-    // render_scene_object.py), donc le même sélecteur suffit.
-    const targetEl = document.querySelector(`[data-element-id="${node.target_element_id || node.target_object_id}"]`);
-    if (targetEl) applyObjectProperty(targetEl, node.element_property, node.element_value);
-    return Promise.resolve();
-  } if (node.action_type === 'declencher_evenement' && node.target_custom_event_id) {
-    // Notification pure (voir screens/custom_events/) : ne fait que
-    // signaler l'événement, jamais choisir un élément — c'est à
-    // l'écouteur (déclencheur → condition → action) de décider quoi
-    // faire, avec ses propres réglages habituels.
-    window.dispatchGameEvent(node.target_custom_event_id);
-    return Promise.resolve();
-  } if (node.action_type === 'activer_onglet' && node.target_element_id) {
-    // 2.3 — panneau à onglets / visibilité mutuellement exclusive : montre
-    // l'élément visé et masque tous ses FRÈRES DIRECTS (même parent_id,
-    // y compris "aucun parent" = les autres éléments de premier niveau de
-    // l'écran) en une seule action, plutôt qu'une action "Masquer" par
-    // frère. screenData.elements contient TOUS les éléments de l'écran
-    // (imbriqués compris, voir list_elements côté serveur), donc ça
-    // fonctionne aussi bien pour des onglets imbriqués dans un même
-    // conteneur que pour des "vues" posées directement sur l'écran.
-    const screenData = screensData.find((s) => s.id === window.currentScreenId);
-    const allElements = screenData ? screenData.elements : [];
-    const target = allElements.find((e) => e.id === node.target_element_id);
-    if (target) {
-      const parentKey = target.parent_id || null;
-      allElements
-        .filter((e) => (e.parent_id || null) === parentKey)
-        .forEach((e) => {
-          const el = document.querySelector(`[data-element-id="${e.id}"]`);
-          if (!el) return;
-          if (e.id === target.id) { el.style.display = ''; el.style.visibility = ''; } else { el.style.display = 'none'; }
-        });
-    }
-    return Promise.resolve();
-  } if (node.action_type === 'attendre') {
-    // 3.2 (Confort) — séquences temporisées : suspend la suite du graphe
-    // pendant N secondes (node.data_value) avant de continuer sur le(s)
-    // fil(s) de sortie — permet par ex. un mail qui "arrive" tout seul
-    // quelques secondes après l'affichage de l'écran, sans action du
-    // joueur (à combiner avec le déclencheur "À l'affichage de l'écran").
-    const seconds = parseFloat(node.data_value);
-    const ms = Number.isNaN(seconds) ? 0 : Math.max(0, seconds) * 1000;
-    return new Promise((resolve) => { setTimeout(resolve, ms); });
-  } if (node.action_type === 'modifier_donnee') {
-    // Export Web/SCORM (voir static/js/play/offline/apply-actions.js) :
-    // aucun serveur disponible dans le paquet exporté — la même mutation
-    // s'applique directement sur gameData, en mémoire, dans le navigateur.
-    if (window.FORGE_OFFLINE) {
-      forgeApplyDataActionOffline(gameData, node);
-      return refreshRuntimeData();
-    }
-    const runDataUrl = FORGE_PLAY_URLS.flowNodeRunData.replace('999999', node.id);
-    // clicked_row_id/last_inserted_row_id : utilisés côté serveur
-    // SEULEMENT si ce nœud vise respectivement CLICKED_ROW_ID ou
-    // LAST_INSERTED_ROW_ID (voir flow_node_run_data.py) — sans effet
-    // sinon, donc toujours transmis sans condition ici.
-    return fetch(runDataUrl, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ clicked_row_id: window.lastClickedRowId, last_inserted_row_id: window.lastInsertedRowId }),
-    })
-      .then((r) => r.json())
-      .then(() => refreshRuntimeData());
-  } if (node.action_type === 'modifier_variable') {
-    if (window.FORGE_OFFLINE) {
-      forgeApplyVariableActionOffline(gameData, node);
-      return refreshRuntimeData();
-    }
-    const runVarUrl = FORGE_PLAY_URLS.flowNodeRunVariable.replace('999999', node.id);
-    return fetch(runVarUrl, { method: 'POST' })
-      .then((r) => r.json())
-      .then(() => refreshRuntimeData());
-  } if (node.action_type === 'modifier_score') {
-    // Score/progression (voir db/scoring/, screens/data_actions/
-    // apply_score_action.py) : même patron que "Modifier une variable
-    // globale" ci-dessus, calculé et écrit côté serveur EN LIGNE, ou
-    // directement en mémoire dans le paquet exporté (voir apply-actions.js).
-    if (window.FORGE_OFFLINE) {
-      forgeApplyScoreActionOffline(gameData, node);
-      return refreshRuntimeData();
-    }
-    const runScoreUrl = FORGE_PLAY_URLS.flowNodeRunScore.replace('999999', node.id);
-    return fetch(runScoreUrl, { method: 'POST' })
-      .then((r) => r.json())
-      .then(() => refreshRuntimeData());
-  } if (node.action_type === 'definir_statut_partie') {
-    if (window.FORGE_OFFLINE) {
-      forgeApplyStatusActionOffline(gameData, node);
-      return refreshRuntimeData();
-    }
-    const runStatusUrl = FORGE_PLAY_URLS.flowNodeRunStatus.replace('999999', node.id);
-    return fetch(runStatusUrl, { method: 'POST' })
-      .then((r) => r.json())
-      .then(() => refreshRuntimeData());
-  } if (node.action_type === 'ajouter_ligne') {
-    // Phase 4 — crée une ligne VIDE (côté serveur en ligne, en mémoire
-    // hors ligne) ; son id devient window.lastInsertedRowId pour que les
-    // nœuds "Modifier une donnée" enchaînés (ciblant LAST_INSERTED_ROW_ID,
-    // "➕ Dernière ligne ajoutée") sachent quelle ligne renseigner.
-    // refreshRuntimeData() affiche la nouvelle ligne dans tout Répéteur lié.
-    if (window.FORGE_OFFLINE) {
-      window.lastInsertedRowId = forgeApplyAddRowActionOffline(gameData, node);
-      return refreshRuntimeData();
-    }
-    const runAddRowUrl = FORGE_PLAY_URLS.flowNodeRunAddRow.replace('999999', node.id);
-    return fetch(runAddRowUrl, { method: 'POST' })
-      .then((r) => r.json())
-      .then((json) => {
-        window.lastInsertedRowId = json.row_id;
-        return refreshRuntimeData();
-      });
-  } if (node.action_type === 'jouer_son') {
-    // Phase 6 — effet sonore ponctuel : non bouclé, indépendant de la
-    // musique de fond de l'écran (runScreenBackgroundMusic() dans
-    // screens.js, qui elle boucle et s'arrête au changement d'écran).
-    // Fire-and-forget : ne bloque jamais la suite du graphe.
-    if (node.data_value) new Audio(node.data_value).play().catch(() => {}); // NOSONAR S2486, CODE_QUALITY.md
-    return Promise.resolve();
-  } if (node.action_type === 'jouer_animation_sprite' && (node.target_element_id || node.target_object_id)) {
-    const spriteTargetId = node.target_element_id || node.target_object_id;
-    const targetEl = document.querySelector(`[data-element-id="${spriteTargetId}"]`);
-    if (targetEl) {
-      let spriteData = {};
-      try {
-        spriteData = JSON.parse(node.data_value || '{}');
-      } catch (e) {
-        // Signalement devtools uniquement (voir CODE_QUALITY.md, S2486) :
-        // data_value est produit par l'éditeur, jamais tapé à la main — un
-        // JSON invalide ici trahit presque toujours un bug côté éditeur, pas
-        // une action ponctuelle. Comportement joueur inchangé : l'animation
-        // reste silencieusement absente (spriteData reste {}).
-        console.warn('configuration sprite invalide', e);
-      }
-      runSpriteAnimation(targetEl, resolveSpriteFrames(spriteTargetId, spriteData));
-    }
-    return Promise.resolve();
-  }
-  // 'rien' : aucune action volontairement.
+function runEcranSuivantAction() {
+  const idx = screenIndexById(window.currentScreenId);
+  if (idx > -1 && idx < screensData.length - 1) showScreen(screensData[idx + 1].id);
   return Promise.resolve();
 }
 
+function runEcranPrecedentAction() {
+  const idx = screenIndexById(window.currentScreenId);
+  if (idx > 0) showScreen(screensData[idx - 1].id);
+  return Promise.resolve();
+}
+
+function runAllerAAction(node) {
+  if (!node.target_screen_id) return Promise.resolve();
+  showScreen(node.target_screen_id);
+  return Promise.resolve();
+}
+
+// Mémorise QUELLE ligne a été cliquée juste avant d'exécuter cette action
+// (voir bindClicks dans triggers.js) puis affiche l'écran de détail avec
+// ses placeholders "champ" résolus contre cette ligne précise.
+function runOuvrirLigneAction(node) {
+  if (!node.target_screen_id) return Promise.resolve();
+  if (window.lastClickedRowId != null && window.lastClickedDefinitionId != null) {
+    window.currentOpenRow = { definitionId: window.lastClickedDefinitionId, rowId: window.lastClickedRowId };
+  }
+  showScreen(node.target_screen_id);
+  applyOpenRowBindings();
+  // Si l'élément "ouvert" (ou un ancêtre commun avec lui) contient AUSSI
+  // un Répéteur — ex. un panneau de détail posé à côté d'une liste dans
+  // le même conteneur — applyOpenRowBindings() vient de régénérer son
+  // sous-arbre, lignes du Répéteur comprises, avec des nœuds tout neufs
+  // SANS AUCUN écouteur de clic (voir bindClicks : le garde-fou anti-
+  // doublon repose sur elDiv.dataset.clickBound, absent sur un nœud
+  // fraîchement créé). Sans ce rappel, un clic sur "ouvrir la ligne
+  // cliquée" combiné à un Répéteur sur le même écran rendait TOUTES les
+  // lignes muettes dès le clic suivant, sans la moindre erreur.
+  bindClicks();
+  bindHoverTexts();
+  bindHoverTriggers();
+  return Promise.resolve();
+}
+
+function runModifierElementAction(node) {
+  if (!node.target_element_id) return Promise.resolve();
+  const targetEl = document.querySelector(`[data-element-id="${node.target_element_id}"]`);
+  if (targetEl) applyElementProperty(targetEl, node.element_property, node.element_value);
+  return Promise.resolve();
+}
+
+// Fondations multi-éditeurs — éditeur de scène 2D : équivalent de
+// "modifier_element" ci-dessus, mais en pixels (voir applyObjectProperty()
+// plus bas) plutôt qu'en %. data-element-id est posé sur CHAQUE objet de
+// scène en plus de data-object-id (voir render_scene_object.py), donc le
+// même sélecteur suffit.
+function runModifierObjetSceneAction(node) {
+  if (!node.target_element_id && !node.target_object_id) return Promise.resolve();
+  const targetEl = document.querySelector(`[data-element-id="${node.target_element_id || node.target_object_id}"]`);
+  if (targetEl) applyObjectProperty(targetEl, node.element_property, node.element_value);
+  return Promise.resolve();
+}
+
+// Notification pure (voir screens/custom_events/) : ne fait que signaler
+// l'événement, jamais choisir un élément — c'est à l'écouteur (déclencheur
+// → condition → action) de décider quoi faire, avec ses propres réglages
+// habituels.
+function runDeclencherEvenementAction(node) {
+  if (!node.target_custom_event_id) return Promise.resolve();
+  window.dispatchGameEvent(node.target_custom_event_id);
+  return Promise.resolve();
+}
+
+// 2.3 — panneau à onglets / visibilité mutuellement exclusive : montre
+// l'élément visé et masque tous ses FRÈRES DIRECTS (même parent_id, y
+// compris "aucun parent" = les autres éléments de premier niveau de
+// l'écran) en une seule action, plutôt qu'une action "Masquer" par frère.
+// screenData.elements contient TOUS les éléments de l'écran (imbriqués
+// compris, voir list_elements côté serveur), donc ça fonctionne aussi
+// bien pour des onglets imbriqués dans un même conteneur que pour des
+// "vues" posées directement sur l'écran.
+function runActiverOngletAction(node) {
+  if (!node.target_element_id) return Promise.resolve();
+  const screenData = screensData.find((s) => s.id === window.currentScreenId);
+  const allElements = screenData ? screenData.elements : [];
+  const target = allElements.find((e) => e.id === node.target_element_id);
+  if (target) {
+    const parentKey = target.parent_id || null;
+    allElements
+      .filter((e) => (e.parent_id || null) === parentKey)
+      .forEach((e) => {
+        const el = document.querySelector(`[data-element-id="${e.id}"]`);
+        if (!el) return;
+        if (e.id === target.id) { el.style.display = ''; el.style.visibility = ''; } else { el.style.display = 'none'; }
+      });
+  }
+  return Promise.resolve();
+}
+
+// 3.2 (Confort) — séquences temporisées : suspend la suite du graphe
+// pendant N secondes (node.data_value) avant de continuer sur le(s)
+// fil(s) de sortie — permet par ex. un mail qui "arrive" tout seul
+// quelques secondes après l'affichage de l'écran, sans action du joueur
+// (à combiner avec le déclencheur "À l'affichage de l'écran").
+function runAttendreAction(node) {
+  const seconds = Number.parseFloat(node.data_value);
+  const ms = Number.isNaN(seconds) ? 0 : Math.max(0, seconds) * 1000;
+  return new Promise((resolve) => { setTimeout(resolve, ms); });
+}
+
+// Export Web/SCORM (voir static/js/play/offline/apply-actions.js) : aucun
+// serveur disponible dans le paquet exporté — la même mutation s'applique
+// directement sur gameData, en mémoire, dans le navigateur.
+function runModifierDonneeAction(node) {
+  if (window.FORGE_OFFLINE) {
+    forgeApplyDataActionOffline(gameData, node);
+    return refreshRuntimeData();
+  }
+  const runDataUrl = FORGE_PLAY_URLS.flowNodeRunData.replace('999999', node.id);
+  // clicked_row_id/last_inserted_row_id : utilisés côté serveur SEULEMENT
+  // si ce nœud vise respectivement CLICKED_ROW_ID ou LAST_INSERTED_ROW_ID
+  // (voir flow_node_run_data.py) — sans effet sinon, donc toujours
+  // transmis sans condition ici.
+  return fetch(runDataUrl, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ clicked_row_id: window.lastClickedRowId, last_inserted_row_id: window.lastInsertedRowId }),
+  })
+    .then((r) => r.json())
+    .then(() => refreshRuntimeData());
+}
+
+function runModifierVariableAction(node) {
+  if (window.FORGE_OFFLINE) {
+    forgeApplyVariableActionOffline(gameData, node);
+    return refreshRuntimeData();
+  }
+  const runVarUrl = FORGE_PLAY_URLS.flowNodeRunVariable.replace('999999', node.id);
+  return fetch(runVarUrl, { method: 'POST' })
+    .then((r) => r.json())
+    .then(() => refreshRuntimeData());
+}
+
+// Score/progression (voir db/scoring/, screens/data_actions/
+// apply_score_action.py) : même patron que "Modifier une variable
+// globale" ci-dessus, calculé et écrit côté serveur EN LIGNE, ou
+// directement en mémoire dans le paquet exporté (voir apply-actions.js).
+function runModifierScoreAction(node) {
+  if (window.FORGE_OFFLINE) {
+    forgeApplyScoreActionOffline(gameData, node);
+    return refreshRuntimeData();
+  }
+  const runScoreUrl = FORGE_PLAY_URLS.flowNodeRunScore.replace('999999', node.id);
+  return fetch(runScoreUrl, { method: 'POST' })
+    .then((r) => r.json())
+    .then(() => refreshRuntimeData());
+}
+
+function runDefinirStatutPartieAction(node) {
+  if (window.FORGE_OFFLINE) {
+    forgeApplyStatusActionOffline(gameData, node);
+    return refreshRuntimeData();
+  }
+  const runStatusUrl = FORGE_PLAY_URLS.flowNodeRunStatus.replace('999999', node.id);
+  return fetch(runStatusUrl, { method: 'POST' })
+    .then((r) => r.json())
+    .then(() => refreshRuntimeData());
+}
+
+// Phase 4 — crée une ligne VIDE (côté serveur en ligne, en mémoire hors
+// ligne) ; son id devient window.lastInsertedRowId pour que les nœuds
+// "Modifier une donnée" enchaînés (ciblant LAST_INSERTED_ROW_ID, "➕
+// Dernière ligne ajoutée") sachent quelle ligne renseigner.
+// refreshRuntimeData() affiche la nouvelle ligne dans tout Répéteur lié.
+function runAjouterLigneAction(node) {
+  if (window.FORGE_OFFLINE) {
+    window.lastInsertedRowId = forgeApplyAddRowActionOffline(gameData, node);
+    return refreshRuntimeData();
+  }
+  const runAddRowUrl = FORGE_PLAY_URLS.flowNodeRunAddRow.replace('999999', node.id);
+  return fetch(runAddRowUrl, { method: 'POST' })
+    .then((r) => r.json())
+    .then((json) => {
+      window.lastInsertedRowId = json.row_id;
+      return refreshRuntimeData();
+    });
+}
+
+// Phase 6 — effet sonore ponctuel : non bouclé, indépendant de la musique
+// de fond de l'écran (runScreenBackgroundMusic() dans screens.js, qui
+// elle boucle et s'arrête au changement d'écran). Fire-and-forget : ne
+// bloque jamais la suite du graphe.
+function runJouerSonAction(node) {
+  if (node.data_value) new Audio(node.data_value).play().catch(() => {}); // NOSONAR S2486, CODE_QUALITY.md
+  return Promise.resolve();
+}
+
+function runJouerAnimationSpriteAction(node) {
+  if (!node.target_element_id && !node.target_object_id) return Promise.resolve();
+  const spriteTargetId = node.target_element_id || node.target_object_id;
+  const targetEl = document.querySelector(`[data-element-id="${spriteTargetId}"]`);
+  if (targetEl) {
+    let spriteData = {};
+    try {
+      spriteData = JSON.parse(node.data_value || '{}');
+    } catch (e) {
+      // Signalement devtools uniquement (voir CODE_QUALITY.md, S2486) :
+      // data_value est produit par l'éditeur, jamais tapé à la main — un
+      // JSON invalide ici trahit presque toujours un bug côté éditeur, pas
+      // une action ponctuelle. Comportement joueur inchangé : l'animation
+      // reste silencieusement absente (spriteData reste {}).
+      console.warn('configuration sprite invalide', e);
+    }
+    runSpriteAnimation(targetEl, resolveSpriteFrames(spriteTargetId, spriteData));
+  }
+  return Promise.resolve();
+}
+
+// Dispatch par action_type — chaque fonction ci-dessus vérifie ELLE-MÊME
+// ses conditions supplémentaires (ex. target_screen_id présent) et
+// renvoie une Promise résolue sans effet si elles ne sont pas remplies ;
+// ce dispatcher n'a donc plus qu'une seule décision (la présence d'un
+// handler), au lieu d'empiler ici les conditions de chaque branche
+// (c'était la source du score S3776 restant à 23 après la 1re extraction
+// en sous-fonctions — un enchaînement de if, même plat, coûte un point
+// par condition ET par opérateur booléen combiné).
+// Clés QUOTÉES délibérément (pas juste un style) : plusieurs tests Python
+// vérifient la présence du littéral quoté ("'jouer_son'" in js, etc.,
+// voir tests/test_sound.py, tests/test_sprite_animation.py,
+// tests/test_flow.py) comme preuve que ce action_type est bien implémenté
+// côté runtime — une clé nue (jouer_son: ...) fait disparaître ce
+// littéral du bundle JS sans rien changer au comportement, mais casse ces
+// tests. Gardé quoté pour rester détectable de la même façon.
+const ACTION_NODE_HANDLERS = {
+  ecran_suivant: runEcranSuivantAction,
+  ecran_precedent: runEcranPrecedentAction,
+  aller_a: runAllerAAction,
+  'ouvrir_ligne': runOuvrirLigneAction, // eslint-disable-line quote-props -- littéral quoté requis, voir commentaire au-dessus de ce dispatch
+  modifier_element: runModifierElementAction,
+  modifier_objet_scene: runModifierObjetSceneAction,
+  declencher_evenement: runDeclencherEvenementAction,
+  activer_onglet: runActiverOngletAction,
+  attendre: runAttendreAction,
+  modifier_donnee: runModifierDonneeAction,
+  modifier_variable: runModifierVariableAction,
+  modifier_score: runModifierScoreAction,
+  definir_statut_partie: runDefinirStatutPartieAction,
+  ajouter_ligne: runAjouterLigneAction,
+  'jouer_son': runJouerSonAction, // eslint-disable-line quote-props -- littéral quoté requis, voir commentaire au-dessus de ce dispatch
+  'jouer_animation_sprite': runJouerAnimationSpriteAction, // eslint-disable-line quote-props -- idem
+};
+
+function runActionNode(node) {
+  const handler = ACTION_NODE_HANDLERS[node.action_type];
+  // 'rien' (ou tout action_type inconnu) : aucune action volontairement.
+  return handler ? handler(node) : Promise.resolve();
+}
+
 // ---------- Phase 7 — animation de sprites (poses/images successives) ----------
 // Premier état actif PAR ÉLÉMENT du moteur (contrairement à
 // activeTimerTriggerIntervals dans triggers.js et currentBackgroundAudio
@@ -382,7 +480,7 @@ const activeSpriteAnimations = new Map();
 // `spriteData.frames` (ancien format, Phase 7) reste géré en repli pour
 // les nœuds/clips déjà créés avant ce changement.
 function resolveSpriteFrames(elementId, spriteData) {
-  const byAnimation = (gameData.personnage_animations || {})[elementId];
+  const byAnimation = gameData.personnage_animations?.[elementId];
   if (byAnimation && spriteData.animation && byAnimation[spriteData.animation]) {
     return { frames: byAnimation[spriteData.animation], fps: spriteData.fps, loop: spriteData.loop };
   }
@@ -418,7 +516,7 @@ function runSpriteAnimation(targetEl, spriteData) {
   const loop = !!spriteData.loop;
   const signature = `${frames.join('|')}@${fps}${loop ? '+loop' : ''}`;
   const active = activeSpriteAnimations.get(targetEl);
-  if (active && active.signature === signature) return;
+  if (active?.signature === signature) return;
   if (active && !active.loop) return;
   if (active) {
     clearInterval(active.intervalId);
@@ -461,6 +559,7 @@ if (typeof module !== 'undefined' && module.exports) {
     runSpriteAnimation,
     stopAllSpriteAnimations,
     activeSpriteAnimations,
+    applyElementProperty,
     applyObjectProperty,
     clampSceneObjectPosition,
     runActionNode,
diff --git a/static/js/play/bindings.js b/static/js/play/bindings.js
index eee02914..d510fff1 100644
--- a/static/js/play/bindings.js
+++ b/static/js/play/bindings.js
@@ -20,6 +20,21 @@
 const PLACEHOLDER_OPEN = '{' + '{';
 const PLACEHOLDER_CLOSE = '}' + '}';
 
+// Partagée entre applyOpenRowBindings() et _forgeApplyFreshRuntimeData()
+// (même algorithme, dupliqué à l'identique dans les deux avant ce
+// refactor S4144) : `byId` explicite en paramètre plutôt que capturé par
+// fermeture, puisque chaque appelant construit sa PROPRE table (éléments
+// de l'écran au moment de son propre appel, jamais partagés entre les
+// deux).
+function isDescendantOfElement(byId, e, ancestorId) {
+  let p = e.parent_id ? byId[e.parent_id] : null;
+  while (p) {
+    if (p.id === ancestorId) return true;
+    p = p.parent_id ? byId[p.parent_id] : null;
+  }
+  return false;
+}
+
 function applyOpenRowBindings() {
   if (!window.currentOpenRow) return;
   const rows = gameData.data[String(window.currentOpenRow.definitionId)] || [];
@@ -53,19 +68,11 @@ function applyOpenRowBindings() {
   const byId = {};
   screenData.elements.forEach((e) => { byId[e.id] = e; });
   function hasUnresolvedPlaceholder(e) {
-    return !!(e.rendered_html && e.rendered_html.indexOf(PLACEHOLDER_OPEN) !== -1);
-  }
-  function isDescendantOf(e, ancestorId) {
-    let p = e.parent_id ? byId[e.parent_id] : null;
-    while (p) {
-      if (p.id === ancestorId) return true;
-      p = p.parent_id ? byId[p.parent_id] : null;
-    }
-    return false;
+    return !!e.rendered_html?.includes(PLACEHOLDER_OPEN);
   }
   const candidates = screenData.elements.filter(hasUnresolvedPlaceholder);
   const targets = candidates.filter(
-    (e) => !candidates.some((other) => other.id !== e.id && isDescendantOf(other, e.id)),
+    (e) => !candidates.some((other) => other.id !== e.id && isDescendantOfElement(byId, other, e.id)),
   );
 
   // Résout {{champ}} EN PLACE dans le DOM déjà affiché, sans jamais
@@ -92,7 +99,7 @@ function applyOpenRowBindings() {
     const toSplit = [];
     let node;
     while ((node = walker.nextNode())) {
-      if (node.nodeValue.indexOf(PLACEHOLDER_OPEN) !== -1) toSplit.push(node);
+      if (node.nodeValue.includes(PLACEHOLDER_OPEN)) toSplit.push(node);
     }
     toSplit.forEach((textNode) => {
       const raw = textNode.nodeValue;
@@ -125,9 +132,12 @@ function applyOpenRowBindings() {
       Array.from(node.attributes).forEach((attr) => {
         if (attr.name.indexOf('data-bind-attr-') === 0) return; // gabarit déjà mémorisé, pas un attribut à lire
         const bindKey = `data-bind-attr-${attr.name}`;
-        const template = node.hasAttribute(bindKey)
-          ? node.getAttribute(bindKey)
-          : (attr.value.indexOf(PLACEHOLDER_OPEN) !== -1 ? attr.value : null);
+        let template = null;
+        if (node.hasAttribute(bindKey)) {
+          template = node.getAttribute(bindKey);
+        } else if (attr.value.includes(PLACEHOLDER_OPEN)) {
+          template = attr.value;
+        }
         if (template === null) return;
         if (!node.hasAttribute(bindKey)) node.setAttribute(bindKey, template);
         placeholderRe.lastIndex = 0;
@@ -227,19 +237,11 @@ function _forgeApplyFreshRuntimeData(newData) {
       const byId = {};
       screenData.elements.forEach((e) => { byId[e.id] = e; });
       const hasMarker = (e) => !!(e.rendered_html && (
-        e.rendered_html.indexOf('repeaterItem') !== -1
-            || e.rendered_html.indexOf('jaugeBar') !== -1
-            || e.rendered_html.indexOf('visibilityGated') !== -1
-            || e.rendered_html.indexOf('dataBound') !== -1
+        e.rendered_html.includes('repeaterItem')
+            || e.rendered_html.includes('jaugeBar')
+            || e.rendered_html.includes('visibilityGated')
+            || e.rendered_html.includes('dataBound')
       ));
-      const isDescendantOf = (e, ancestorId) => {
-        let p = e.parent_id ? byId[e.parent_id] : null;
-        while (p) {
-          if (p.id === ancestorId) return true;
-          p = p.parent_id ? byId[p.parent_id] : null;
-        }
-        return false;
-      };
       // "visibilityGated"/"dataBound" sont posés comme un COMMENTAIRE
       // HTML juste après la balise concernée (voir _mark() dans
       // render_element_html.py) — jamais comme une classe CSS, à la
@@ -254,13 +256,13 @@ function _forgeApplyFreshRuntimeData(newData) {
       // l'identifie, son marqueur ne remontant jusqu'au SEUL élément
       // de premier niveau existant (l'exemplaire) que parce que son
       // HTML est imbriqué dans le sien.
-      const COMMENT_MARKERS = ['visibilityGated', 'dataBound'];
+      const COMMENT_MARKERS = new Set(['visibilityGated', 'dataBound']);
       const findCommentMarkedDescendants = (root) => {
         const found = [];
         root.querySelectorAll('[data-element-id]').forEach((node) => {
           const sib = node.nextSibling;
           const hasCommentMarker = !!(
-            sib && sib.nodeType === Node.COMMENT_NODE && COMMENT_MARKERS.indexOf(sib.data) !== -1
+            sib?.nodeType === Node.COMMENT_NODE && COMMENT_MARKERS.has(sib.data)
           );
           // Un élément actuellement CACHÉ par une condition de
           // visibilité (voir render_element_html.py) n'a pas de
@@ -282,7 +284,7 @@ function _forgeApplyFreshRuntimeData(newData) {
       };
       const markedCandidates = screenData.elements.filter(hasMarker);
       markedCandidates
-        .filter((e) => !markedCandidates.some((other) => other.id !== e.id && isDescendantOf(other, e.id)))
+        .filter((e) => !markedCandidates.some((other) => other.id !== e.id && isDescendantOfElement(byId, other, e.id)))
         .forEach((el) => {
           const target = screenDiv.querySelector(`[data-element-id="${el.id}"]`);
           if (!target) return;
@@ -299,7 +301,7 @@ function _forgeApplyFreshRuntimeData(newData) {
           // disparaître ni réapparaître juste parce qu'un texte à
           // l'intérieur a changé.
             innerMarked.forEach((innerNode) => {
-              const innerId = innerNode.getAttribute('data-element-id');
+              const innerId = innerNode.dataset.elementId;
               const liveInner = target.querySelector(`[data-element-id="${innerId}"]`);
               if (liveInner) liveInner.replaceWith(innerNode);
             });
diff --git a/static/js/play/collision-rules-controller.js b/static/js/play/collision-rules-controller.js
index dfaaa014..7d9e72a1 100644
--- a/static/js/play/collision-rules-controller.js
+++ b/static/js/play/collision-rules-controller.js
@@ -25,10 +25,10 @@ function forgeCollisionRuleStateKey(objectId, ruleIndex) {
 }
 
 function forgeElementBoxRect(el, collision) {
-  const left = parseFloat(el.style.left) || 0;
-  const top = parseFloat(el.style.top) || 0;
-  const width = parseFloat(el.style.width) || 0;
-  const height = parseFloat(el.style.height) || 0;
+  const left = Number.parseFloat(el.style.left) || 0;
+  const top = Number.parseFloat(el.style.top) || 0;
+  const width = Number.parseFloat(el.style.width) || 0;
+  const height = Number.parseFloat(el.style.height) || 0;
   return forgeCollisionRectFromBox({
     left, top, width, height,
   }, collision);
@@ -86,7 +86,7 @@ function forgeCollisionInteractBubbleEl(objectId, parentEl) {
   if (!bubble) {
     bubble = document.createElement('div');
     bubble.className = 'collisionInteractBubble';
-    bubble.setAttribute('data-for-object-id', objectId);
+    bubble.dataset.forObjectId = objectId;
     parentEl.appendChild(bubble);
   }
   return bubble;
@@ -112,8 +112,8 @@ function forgeShowCollisionInteractBubble(objectEl, objectId, objRect, key) {
 }
 
 function forgeHideCollisionInteractBubble(objectId, objectEl) {
-  const parentEl = objectEl && objectEl.parentElement;
-  const bubble = parentEl && parentEl.querySelector(`.collisionInteractBubble[data-for-object-id="${objectId}"]`);
+  const parentEl = objectEl?.parentElement;
+  const bubble = parentEl?.querySelector(`.collisionInteractBubble[data-for-object-id="${objectId}"]`);
   if (bubble) bubble.style.display = 'none';
 }
 
@@ -131,7 +131,7 @@ function forgeIndicationBubbleEl(objectId, parentEl) {
   if (!bubble) {
     bubble = document.createElement('div');
     bubble.className = 'collisionIndicationBubble';
-    bubble.setAttribute('data-for-object-id', objectId);
+    bubble.dataset.forObjectId = objectId;
     parentEl.appendChild(bubble);
   }
   return bubble;
@@ -139,7 +139,7 @@ function forgeIndicationBubbleEl(objectId, parentEl) {
 
 function forgeShowIndicationBubble(objectId, texte, dureeMs) {
   const targetEl = document.querySelector(`[data-object-id="${objectId}"]`);
-  const parentEl = targetEl && targetEl.parentElement;
+  const parentEl = targetEl?.parentElement;
   if (!targetEl || !parentEl || !texte) return;
   const objRect = forgeElementBoxRect(targetEl);
   const bubble = forgeIndicationBubbleEl(objectId, parentEl);
@@ -153,85 +153,114 @@ function forgeShowIndicationBubble(objectId, texte, dureeMs) {
   }, dureeMs || FORGE_INDICATION_DEFAULT_DURATION_MS);
 }
 
+// Affiche LE DIALOGUE DE CETTE ACTION PRÉCISE (action.dialogue.lines —
+// chaque occurrence de "Déclencher ce dialogue" porte le sien, voir
+// screens/rendering/collision_rules.py) dans le widget "💬 Boîte de
+// dialogue" posé sur l'écran (voir static/js/play/dialogue-box-
+// controller.js) — sans effet si aucun widget n'est posé, comme le reste
+// de ce moteur. Le nom affiché (en-tête du quiz, xAPI) est celui de
+// l'objet déclencheur (voir "ℹ️ Informations") — plus de "quête" pour le
+// porter. mark_completed (optionnel) : marque ce dialogue terminé une
+// fois épuisé. `action.then` (chaînage, voir maquette validée : "pouvoir
+// modifier un déclencheur pour lui ajouter des actions") NE PEUT PAS
+// s'exécuter immédiatement — un dialogue attend des clics du joueur —
+// transmis à forgeShowDialogueBox, exécuté par dialogue-box-controller.js
+// une fois le dialogue épuisé.
+function runDialogueCollisionAction(action, targetEl, obj) {
+  const lines = action.dialogue?.lines || [];
+  const dialogueId = action.dialogue?.id;
+  forgeShowDialogueBox(dialogueId, obj.name || 'PNJ', lines, action.mark_completed, action.then);
+}
+
+// Modifie une variable globale — même vocabulaire/calcul que l'action
+// "Modifier une variable" du graphe de logique document (voir
+// screens/data_actions/apply_variable_action.py), portée ici par
+// forgeApplyVariableActionOffline (static/js/play/offline/apply-actions.js,
+// TOUJOURS chargée — voir templates/play.html — pas seulement en export,
+// donc aucun branchement FORGE_OFFLINE nécessaire, même philosophie que
+// le reste de ce fichier). Instantané : `then` s'exécute tout de suite,
+// contrairement à un dialogue.
+function runVariableCollisionAction(action, targetEl, obj) {
+  forgeApplyVariableActionOffline(gameData, action);
+  if (action.then) forgeRunCollisionRuleAction(action.then, targetEl, obj);
+}
+
+// Réutilise evaluateConditionClause (static/js/play/conditions.js), même
+// comparaison qu'un nœud Condition de l'éditeur de logique, sur une
+// VARIABLE GLOBALE (gameData.variables) — jamais un champ d'objet ici
+// (voir maquette validée : le losange ne teste qu'une variable).
+function runConditionCollisionAction(action, targetEl, obj) {
+  const isTrue = evaluateConditionClause({
+    source: 'variable', variable: action.variable, operator: action.operateur, value: action.valeur,
+  });
+  const branch = isTrue ? action.si_vrai : action.si_faux;
+  if (branch) forgeRunCollisionRuleAction(branch, targetEl, obj);
+}
+
+// Cible N'IMPORTE QUEL objet de l'écran (action.object_id, pas forcément
+// celui qui porte le déclencheur) — réutilise TEL QUEL applyObjectProperty
+// (static/js/play/actions.js, équivalent scène 2D d'applyElementProperty),
+// plutôt que de dupliquer cette logique. Partagée entre "surbrillance" et
+// "visibilite", qui suivent exactement le même patron.
+function runSurbrillanceOuVisibiliteCollisionAction(action, targetEl, obj) {
+  const targetObjEl = document.querySelector(`[data-object-id="${action.object_id}"]`);
+  if (targetObjEl) applyObjectProperty(targetObjEl, action.type, action.valeur);
+  if (action.then) forgeRunCollisionRuleAction(action.then, targetEl, obj);
+}
+
+// Effet sonore ponctuel, non bouclé — même comportement que l'action
+// "Jouer un son" du Flow (static/js/play/actions.js), instantané : `then`
+// s'exécute tout de suite, sans attendre la fin du son.
+function runSonCollisionAction(action, targetEl, obj) {
+  if (action.asset_url) new Audio(action.asset_url).play().catch(() => {});
+  if (action.then) forgeRunCollisionRuleAction(action.then, targetEl, obj);
+}
+
+// Bloque la suite de la chaîne "then" jusqu'à la fin de la vidéo (ou
+// "Passer") — voir static/js/play/video-overlay.js, même esprit qu'un
+// dialogue ci-dessus.
+function runVideoCollisionAction(action, targetEl, obj) {
+  forgeShowVideoOverlay(action.asset_url, action.mode, () => {
+    if (action.then) forgeRunCollisionRuleAction(action.then, targetEl, obj);
+  });
+}
+
+function runIndicationCollisionAction(action, targetEl, obj) {
+  forgeShowIndicationBubble(action.object_id, action.texte, action.duree_ms);
+  if (action.then) forgeRunCollisionRuleAction(action.then, targetEl, obj);
+}
+
+// Suspend la chaîne "then" pendant data_value SECONDES — même vocabulaire
+// que l'action "attendre" du Flow (static/js/play/actions.js), utile ex.
+// pour laisser un temps de lecture après une narration à l'affichage de
+// l'écran.
+function runAttendreCollisionAction(action, targetEl, obj) {
+  const seconds = Number.parseFloat(action.data_value);
+  const ms = Number.isNaN(seconds) ? 0 : Math.max(0, seconds) * 1000;
+  setTimeout(() => {
+    if (action.then) forgeRunCollisionRuleAction(action.then, targetEl, obj);
+  }, ms);
+}
+
+const COLLISION_RULE_ACTION_HANDLERS = {
+  dialogue: runDialogueCollisionAction,
+  variable: runVariableCollisionAction,
+  condition: runConditionCollisionAction,
+  surbrillance: runSurbrillanceOuVisibiliteCollisionAction,
+  visibilite: runSurbrillanceOuVisibiliteCollisionAction,
+  son: runSonCollisionAction,
+  video: runVideoCollisionAction,
+  indication: runIndicationCollisionAction,
+  attendre: runAttendreCollisionAction,
+};
+
 // Exécute une action (top-level, sub_action d'un "interagir", ou branche
 // si_vrai/si_faux d'une "condition") — jamais appelée pour un "interagir"
 // lui-même à ce niveau, voir forgeCollisionRuleTick qui le gère à part
 // (affichage de bulle + attente de touche).
 function forgeRunCollisionRuleAction(action, targetEl, obj) {
-  if (action.type === 'dialogue') {
-    // Affiche LE DIALOGUE DE CETTE ACTION PRÉCISE (action.dialogue.lines
-    // — chaque occurrence de "Déclencher ce dialogue" porte le sien,
-    // voir screens/rendering/collision_rules.py) dans le widget "💬 Boîte
-    // de dialogue" posé sur l'écran (voir static/js/play/
-    // dialogue-box-controller.js) — sans effet si aucun widget n'est
-    // posé, comme le reste de ce moteur. Le nom affiché (en-tête du
-    // quiz, xAPI) est celui de l'objet déclencheur (voir "ℹ️
-    // Informations") — plus de "quête" pour le porter. mark_completed
-    // (optionnel) : marque ce dialogue terminé une fois épuisé.
-    // `action.then` (chaînage, voir maquette validée : "pouvoir modifier
-    // un déclencheur pour lui ajouter des actions") NE PEUT PAS
-    // s'exécuter immédiatement — un dialogue attend des clics du joueur
-    // — transmis à forgeShowDialogueBox, exécuté par dialogue-box-
-    // controller.js une fois le dialogue épuisé.
-    const lines = (action.dialogue && action.dialogue.lines) || [];
-    const dialogueId = action.dialogue && action.dialogue.id;
-    forgeShowDialogueBox(dialogueId, obj.name || 'PNJ', lines, action.mark_completed, action.then);
-  } else if (action.type === 'variable') {
-    // Modifie une variable globale — même vocabulaire/calcul que l'action
-    // "Modifier une variable" du graphe de logique document (voir
-    // screens/data_actions/apply_variable_action.py), portée ici par
-    // forgeApplyVariableActionOffline (static/js/play/offline/apply-actions.js,
-    // TOUJOURS chargée — voir templates/play.html — pas seulement en
-    // export, donc aucun branchement FORGE_OFFLINE nécessaire, même
-    // philosophie que le reste de ce fichier). Instantané : `then`
-    // s'exécute tout de suite, contrairement à un dialogue.
-    forgeApplyVariableActionOffline(gameData, action);
-    if (action.then) forgeRunCollisionRuleAction(action.then, targetEl, obj);
-  } else if (action.type === 'condition') {
-    // Réutilise evaluateConditionClause (static/js/play/conditions.js),
-    // même comparaison qu'un nœud Condition de l'éditeur de logique, sur
-    // une VARIABLE GLOBALE (gameData.variables) — jamais un champ d'objet
-    // ici (voir maquette validée : le losange ne teste qu'une variable).
-    const isTrue = evaluateConditionClause({
-      source: 'variable', variable: action.variable, operator: action.operateur, value: action.valeur,
-    });
-    const branch = isTrue ? action.si_vrai : action.si_faux;
-    if (branch) forgeRunCollisionRuleAction(branch, targetEl, obj);
-  } else if (action.type === 'surbrillance' || action.type === 'visibilite') {
-    // Cible N'IMPORTE QUEL objet de l'écran (action.object_id, pas
-    // forcément celui qui porte le déclencheur) — réutilise TEL QUEL
-    // applyObjectProperty (static/js/play/actions.js, équivalent scène 2D
-    // d'applyElementProperty), plutôt que de dupliquer cette logique.
-    const targetObjEl = document.querySelector(`[data-object-id="${action.object_id}"]`);
-    if (targetObjEl) applyObjectProperty(targetObjEl, action.type, action.valeur);
-    if (action.then) forgeRunCollisionRuleAction(action.then, targetEl, obj);
-  } else if (action.type === 'son') {
-    // Effet sonore ponctuel, non bouclé — même comportement que l'action
-    // "Jouer un son" du Flow (static/js/play/actions.js), instantané :
-    // `then` s'exécute tout de suite, sans attendre la fin du son.
-    if (action.asset_url) new Audio(action.asset_url).play().catch(() => {});
-    if (action.then) forgeRunCollisionRuleAction(action.then, targetEl, obj);
-  } else if (action.type === 'video') {
-    // Bloque la suite de la chaîne "then" jusqu'à la fin de la vidéo (ou
-    // "Passer") — voir static/js/play/video-overlay.js, même esprit
-    // qu'un dialogue ci-dessus.
-    forgeShowVideoOverlay(action.asset_url, action.mode, () => {
-      if (action.then) forgeRunCollisionRuleAction(action.then, targetEl, obj);
-    });
-  } else if (action.type === 'indication') {
-    forgeShowIndicationBubble(action.object_id, action.texte, action.duree_ms);
-    if (action.then) forgeRunCollisionRuleAction(action.then, targetEl, obj);
-  } else if (action.type === 'attendre') {
-    // Suspend la chaîne "then" pendant data_value SECONDES — même
-    // vocabulaire que l'action "attendre" du Flow (static/js/play/
-    // actions.js), utile ex. pour laisser un temps de lecture après une
-    // narration à l'affichage de l'écran.
-    const seconds = parseFloat(action.data_value);
-    const ms = Number.isNaN(seconds) ? 0 : Math.max(0, seconds) * 1000;
-    setTimeout(() => {
-      if (action.then) forgeRunCollisionRuleAction(action.then, targetEl, obj);
-    }, ms);
-  }
+  const handler = COLLISION_RULE_ACTION_HANDLERS[action.type];
+  if (handler) handler(action, targetEl, obj);
 }
 
 function forgeCollisionRuleTick(screenData) {
@@ -242,7 +271,7 @@ function forgeCollisionRuleTick(screenData) {
 
   (screenData.elements || []).forEach((obj) => {
     const rules = obj.collision_rules;
-    if (!rules || !rules.length) return;
+    if (!rules?.length) return;
     const targetEl = document.querySelector(`[data-object-id="${obj.id}"]`);
     if (!targetEl) return;
     const objRect = forgeElementBoxRect(targetEl, obj.collision);
@@ -261,7 +290,7 @@ function forgeCollisionRuleTick(screenData) {
       if (rule.action.type === 'interagir') {
         if (isActive) {
           anyInteractActive = true;
-          forgeShowCollisionInteractBubble(targetEl, obj.id, objRect, (player.personnage_commandes && player.personnage_commandes.interagir) || 'E');
+          forgeShowCollisionInteractBubble(targetEl, obj.id, objRect, player.personnage_commandes?.interagir || 'E');
         }
         forgeCollisionRuleActiveState[stateKey] = isActive;
         return;
@@ -280,10 +309,10 @@ function forgeCollisionRuleTick(screenData) {
 function forgeStartCollisionRuleInteractListener(screenData) {
   activeCollisionRuleInteractListener = function (ev) {
     const player = (screenData.elements || []).find((o) => o.kind === 'personnage' && o.personnage_role === 'joueur');
-    if (!player || !player.personnage_commandes || ev.key !== player.personnage_commandes.interagir) return;
+    if (!player?.personnage_commandes || ev.key !== player.personnage_commandes.interagir) return;
     (screenData.elements || []).forEach((obj) => {
       const rules = obj.collision_rules;
-      if (!rules || !rules.length) return;
+      if (!rules?.length) return;
       const targetEl = document.querySelector(`[data-object-id="${obj.id}"]`);
       if (!targetEl) return;
       rules.forEach((rule, ruleIndex) => {
@@ -314,7 +343,7 @@ function forgeBindClicSurvolRules(screenData) {
   forgeUnbindClicSurvolRules();
   (screenData.elements || []).forEach((obj) => {
     const rules = obj.collision_rules;
-    if (!rules || !rules.length) return;
+    if (!rules?.length) return;
     const targetEl = document.querySelector(`[data-object-id="${obj.id}"]`);
     if (!targetEl) return;
     rules.forEach((rule) => {
@@ -347,11 +376,11 @@ function forgeStopCollisionRuleControllers() {
 // ET au moins un objet avec des règles.
 function forgeStartCollisionRuleControllers(screenData) {
   forgeStopCollisionRuleControllers();
-  if (!screenData || screenData.kind !== 'jeu_2d') return;
+  if (screenData?.kind !== 'jeu_2d') return;
   const elements = screenData.elements || [];
   forgeBindClicSurvolRules(screenData);
   const hasPlayer = elements.some((o) => o.kind === 'personnage' && o.personnage_role === 'joueur');
-  const hasRules = elements.some((o) => o.collision_rules && o.collision_rules.length);
+  const hasRules = elements.some((o) => o.collision_rules?.length);
   if (!hasPlayer || !hasRules) return;
   activeCollisionRuleInterval = setInterval(() => { forgeCollisionRuleTick(screenData); }, 50);
   forgeStartCollisionRuleInteractListener(screenData);
diff --git a/static/js/play/conditions.js b/static/js/play/conditions.js
index ec9c7d38..a61600ba 100644
--- a/static/js/play/conditions.js
+++ b/static/js/play/conditions.js
@@ -43,8 +43,8 @@ function compareValues(actual, operator, expected, fieldType) {
     const e = normalizeBool(expected);
     return operator === 'different' ? a !== e : a === e;
   }
-  const an = parseFloat(actual); const
-    en = parseFloat(expected);
+  const an = Number.parseFloat(actual); const
+    en = Number.parseFloat(expected);
   const numeric = !Number.isNaN(an) && !Number.isNaN(en);
   if (numeric) {
     switch (operator) {
@@ -87,7 +87,7 @@ function compareValues(actual, operator, expected, fieldType) {
 // nécessaire ici : le nom de la variable est choisi dans un menu
 // déroulant, voir screen_edit.html).
 function readVariableValue(name) {
-  const v = (gameData.variables || {})[name];
+  const v = gameData.variables?.[name];
   return v ? v.value : undefined;
 }
 
@@ -105,7 +105,7 @@ function resolveVariablePath(rawValue, path) {
   let m;
   while ((m = segmentRe.exec(path)) !== null) {
     if (current === null || current === undefined) return null;
-    current = m[1] !== undefined ? current[m[1]] : current[parseInt(m[2], 10)];
+    current = m[1] !== undefined ? current[m[1]] : current[Number.parseInt(m[2], 10)];
   }
   return current === undefined ? null : current;
 }
@@ -129,13 +129,13 @@ function resolveVariablePath(rawValue, path) {
 // PURE (aucun accès DOM) — testée par static/js/play/__tests__/
 // conditions.test.js, contrairement à elementsOverlap() ci-dessous.
 function forgeCollisionRectFromBox(box, collision) {
-  const width = (collision && collision.width) || box.width;
-  const height = (collision && collision.height) || box.height;
-  const offsetX = (collision && collision.offset_x) || 0;
-  const offsetY = (collision && collision.offset_y) || 0;
+  const width = collision?.width || box.width;
+  const height = collision?.height || box.height;
+  const offsetX = collision?.offset_x || 0;
+  const offsetY = collision?.offset_y || 0;
   const left = box.left + (box.width - width) / 2 + offsetX;
   const top = box.top + (box.height - height) / 2 + offsetY;
-  const shape = (collision && collision.shape) || 'rectangle';
+  const shape = collision?.shape || 'rectangle';
   return {
     left, top, right: left + width, bottom: top + height, width, height, shape,
   };
@@ -156,7 +156,7 @@ function forgeCirclesOverlap(a, b) {
     br = Math.min(b.width, b.height) / 2;
   const dx = acx - bcx; const
     dy = acy - bcy;
-  return Math.sqrt(dx * dx + dy * dy) < (ar + br);
+  return Math.hypot(dx, dy) < (ar + br);
 }
 
 // Choisit rectangle-rectangle ou cercle-cercle selon la forme des DEUX
@@ -190,13 +190,13 @@ function elementsOverlap(elementIdA, elementIdB) {
   const objA = screenData && (screenData.elements || []).find((o) => o.id === elementIdA);
   const objB = screenData && (screenData.elements || []).find((o) => o.id === elementIdB);
   if (
-    (objA && objA.collision && objA.collision.enabled === false)
-    || (objB && objB.collision && objB.collision.enabled === false)
+    objA?.collision?.enabled === false
+    || objB?.collision?.enabled === false
   ) {
     return false;
   }
-  const rectA = forgeCollisionRectFromBox(a.getBoundingClientRect(), objA && objA.collision);
-  const rectB = forgeCollisionRectFromBox(b.getBoundingClientRect(), objB && objB.collision);
+  const rectA = forgeCollisionRectFromBox(a.getBoundingClientRect(), objA?.collision);
+  const rectB = forgeCollisionRectFromBox(b.getBoundingClientRect(), objB?.collision);
   return forgeShapesOverlap(rectA, rectB);
 }
 
@@ -215,9 +215,9 @@ function evaluateConditionClause(clause) {
   if (source === 'variable') {
     const varName = clause.variable ?? clause.cond_variable;
     const path = clause.variable_chemin ?? clause.cond_variable_chemin;
-    const varInfo = (gameData.variables || {})[varName];
+    const varInfo = gameData.variables?.[varName];
     const actual = resolveVariablePath(readVariableValue(varName), path);
-    const fieldType = varInfo && varInfo.type === 'booleen' ? 'booleen' : '';
+    const fieldType = varInfo?.type === 'booleen' ? 'booleen' : '';
     return compareValues(actual, operator, expected, fieldType);
   }
   const actual = readFieldValue(
diff --git a/static/js/play/dialogue-box-controller.js b/static/js/play/dialogue-box-controller.js
index 7057d179..b3b58429 100644
--- a/static/js/play/dialogue-box-controller.js
+++ b/static/js/play/dialogue-box-controller.js
@@ -56,8 +56,8 @@ window.forgeCompletedDialogueIds = window.forgeCompletedDialogueIds || {};
 
 function forgeEscapeHtml(str) {
   return String(str == null ? '' : str)
-    .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
-    .replace(/"/g, '&quot;');
+    .replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;');
 }
 
 // ---------- Boîte de dialogue ----------
@@ -141,7 +141,7 @@ function forgeQuizBoxWidgetById(objectId) {
 function forgeEscapeCameraForFullscreen(widget) {
   if (widget.parentNode === document.body) return;
   const screenEl = widget.closest('.playScreen');
-  if (screenEl) widget.setAttribute('data-owner-screen-id', screenEl.getAttribute('data-screen-id'));
+  if (screenEl) widget.dataset.ownerScreenId = screenEl.dataset.screenId;
   widget.classList.add('quizBoxWidget--detachedForFullscreen');
   document.body.appendChild(widget);
 }
@@ -155,7 +155,7 @@ function forgeHideQuizBoxOnCurrentScreen() {
   const widget = forgeQuizBoxWidgetOnCurrentScreen();
   if (!widget) return;
   widget.classList.remove('is-active', 'is-fullscreen');
-  const objectId = widget.getAttribute('data-object-id');
+  const objectId = widget.dataset.objectId;
   forgeStopQuizTimer(objectId);
 }
 
@@ -171,7 +171,7 @@ const forgeQuizTimerState = {};
 
 function forgeStopQuizTimer(objectId) {
   const t = forgeQuizTimerState[objectId];
-  if (t && t.intervalId) clearInterval(t.intervalId);
+  if (t?.intervalId) clearInterval(t.intervalId);
   delete forgeQuizTimerState[objectId];
 }
 
@@ -207,7 +207,7 @@ function forgeStartQuizTimer(objectId, widget, seconds, onExpire) {
 
 function forgeUpdateAllScoreWidgets() {
   const values = document.querySelectorAll('.scoreWidget [data-score-role="value"]');
-  for (let i = 0; i < values.length; i++) values[i].textContent = window.forgeQuizScore;
+  for (const value of values) value.textContent = window.forgeQuizScore;
   forgeUpdateQuizBoxScoreDisplays();
 }
 
@@ -218,7 +218,7 @@ function forgeUpdateAllScoreWidgets() {
 // non-plein-écran, mais tenu à jour dans tous les cas (coûte rien).
 function forgeUpdateQuizBoxScoreDisplays() {
   const values = document.querySelectorAll('.quizBoxWidget [data-quiz-role="score"]');
-  for (let i = 0; i < values.length; i++) values[i].textContent = `Score : ${window.forgeQuizScore}`;
+  for (const value of values) value.textContent = `Score : ${window.forgeQuizScore}`;
 }
 
 // Alimente aussi gameData.scoring (voir static/js/play/offline/
@@ -341,7 +341,7 @@ function forgeShowDialogueBox(dialogueId, objectName, lines, markCompleted, then
   // forgeShowCurrentConversationLine), même logique symétrique qu'une
   // question sans boîte à quiz posée (voir forgeShowQuizBox).
   const widget = forgeDialogueBoxWidgetOnCurrentScreen();
-  const stateKey = widget ? widget.getAttribute('data-object-id') : (`_sansBoiteDialogue_${dialogueId}`);
+  const stateKey = widget ? widget.dataset.objectId : (`_sansBoiteDialogue_${dialogueId}`);
   forgeSyncDialogueStartedToScorm();
   if (!lines.length) {
     // Rien à jouer : applique quand même markCompleted PUIS thenAction
@@ -400,7 +400,7 @@ function forgeAdvanceConversation(dialogueObjectId) {
 // voir forgeShowCurrentConversationLine, mais gardé strict par sécurité).
 function forgeDialogueBoxAdvance(objectId) {
   const state = forgeDialogueBoxState[objectId];
-  if (!state || (state.lines[state.index] && state.lines[state.index].type === 'question')) return;
+  if (!state || state.lines[state.index]?.type === 'question') return;
   forgeAdvanceConversation(objectId);
 }
 
@@ -413,7 +413,7 @@ function forgeDialogueBoxAdvance(objectId) {
 function forgeShowQuizBox(dialogueObjectId, dialogueId, objectName, line, questionIndex) {
   const widget = forgeQuizBoxWidgetOnCurrentScreen();
   if (!widget) { forgeAdvanceConversation(dialogueObjectId); return; }
-  const quizObjectId = widget.getAttribute('data-object-id');
+  const quizObjectId = widget.dataset.objectId;
   const previousState = forgeQuizBoxState[quizObjectId];
   forgeQuizBoxState[quizObjectId] = {
     dialogueObjectId,
@@ -456,14 +456,14 @@ function forgeShowQuizBox(dialogueObjectId, dialogueId, objectName, line, questi
   // static/style.css). Échappe d'abord au conteneur de scène transformé
   // (voir forgeEscapeCameraForFullscreen) — sinon position:fixed reste
   // borné à sa taille "caméra" au lieu du vrai écran du joueur.
-  const isFullscreen = widget.getAttribute('data-fullscreen') === '1';
+  const isFullscreen = widget.dataset.fullscreen === '1';
   if (isFullscreen) forgeEscapeCameraForFullscreen(widget);
   widget.classList.toggle('is-fullscreen', isFullscreen);
   forgeUpdateQuizBoxScoreDisplays();
   // Minuteur (optionnel — "aucun" reste le réglage par défaut, jamais
   // imposé, voir screens/rendering/quiz_box_config.py).
-  const timerMode = widget.getAttribute('data-timer-mode');
-  const timerSeconds = parseInt(widget.getAttribute('data-timer-seconds'), 10) || 0;
+  const timerMode = widget.dataset.timerMode;
+  const timerSeconds = Number.parseInt(widget.dataset.timerSeconds, 10) || 0;
   if (timerMode === 'question') {
     forgeStartQuizTimer(quizObjectId, widget, timerSeconds, () => { forgeQuizBoxTimeout(quizObjectId, false); });
   } else if (timerMode === 'quiz' && !forgeQuizBoxState[quizObjectId].quizTimerStarted) {
@@ -477,7 +477,17 @@ function forgeShowQuizBox(dialogueObjectId, dialogueId, objectName, line, questi
   // ce retrait/reflow/réajout, une classe déjà posée ne redéclenche pas
   // son animation CSS.
   widget.classList.remove('is-active');
-  void widget.offsetWidth;
+  // Lecture volontairement sans effet apparent : force le navigateur à
+  // calculer la mise en page AVANT le .add() ci-dessous (sans ça, les deux
+  // changements de classe sont fusionnés en une seule passe de rendu et
+  // l'animation ne redémarre jamais). `void` est la forme la plus claire
+  // pour marquer une expression délibérément ignorée (accepté par ESLint,
+  // no-unused-expressions désactivé dans ce projet) — Sonar n'a aucun
+  // idiome qu'il reconnaisse pour ce cas : S3735 (void), S905 (expression
+  // seule sans void) et S1481 (variable jamais lue) se sont succédé sur
+  // les 3 formes essayées, chacune corrigeant la précédente en en créant
+  // une autre. NOSONAR ici plutôt que de continuer, voir CODE_QUALITY.md.
+  void widget.offsetWidth; // NOSONAR S3735 - reflow force, aucune forme alternative ne satisfait Sonar, CODE_QUALITY.md
   widget.classList.add('is-active');
   // Effet d'entrée propre au modèle (voir static/js/play/
   // quiz-box-templates.js) — optionnel, "defaut" n'en a aucun.
@@ -489,42 +499,27 @@ function forgeShowQuizBox(dialogueObjectId, dialogueId, objectName, line, questi
 // templates.js, chargé AVANT ce fichier) — absent en environnement de
 // test qui ne charge pas ce script, d'où la garde `typeof`.
 function forgeQuizTemplateEffectsFor(widget) {
-  const template = (widget && widget.getAttribute('data-quiz-template')) || 'defaut';
+  const template = widget?.dataset.quizTemplate || 'defaut';
   return (typeof forgeQuizTemplateEffects !== 'undefined' && forgeQuizTemplateEffects[template]) || {};
 }
 
-// Appelée par le clic sur un choix (les boutons sont injectés EN JEU par
-// forgeShowQuizBox ci-dessus, jamais rendus côté serveur — voir
-// render_scene_object.py pour le seul aperçu statique de l'éditeur).
-// TOUJOURS crédite le score si la réponse est bonne PUIS avance à la
-// ligne suivante, QUE la réponse soit bonne ou mauvaise (demande
-// explicite : une mauvaise réponse ne doit jamais bloquer la
-// progression) — surligne la bonne réponse en vert (et le choix cliqué
-// en rouge s'il était faux) le temps de la voir avant d'avancer. Un
-// second clic pendant cet affichage est ignoré (`resolved`).
-function forgeQuizBoxAnswer(quizObjectId, choiceIndex) {
-  const state = forgeQuizBoxState[quizObjectId];
-  if (!state || state.resolved) return;
-  state.resolved = true;
-  const widget = forgeQuizBoxWidgetById(quizObjectId);
-  const correct = choiceIndex === state.correctIndex;
-  // Minuteur "par question" : cette question est résolue (bonne réponse,
-  // mauvaise réponse, OU minuteur expiré via forgeQuizBoxTimeout, qui
-  // appelle CETTE fonction avec choiceIndex=-1) — jamais le minuteur
-  // "pour tout le quiz", qui doit continuer à tourner sans interruption
-  // d'une question à l'autre.
-  if (widget && widget.getAttribute('data-timer-mode') === 'question') forgeStopQuizTimer(quizObjectId);
-  if (widget) {
-    const buttons = widget.querySelectorAll('.quizBoxChoiceBtn');
-    for (let i = 0; i < buttons.length; i++) {
-      buttons[i].disabled = true;
-      if (i === state.correctIndex) buttons[i].classList.add('is-correct');
-      else if (i === choiceIndex) buttons[i].classList.add('is-wrong');
-    }
+// Surligne la bonne réponse en vert (et le choix cliqué en rouge s'il
+// était faux) sur les boutons injectés par forgeShowQuizBox — extrait de
+// forgeQuizBoxAnswer (lot 4 "modernisation JS", S3776).
+function markQuizChoiceButtons(widget, state, choiceIndex) {
+  if (!widget) return;
+  const buttons = widget.querySelectorAll('.quizBoxChoiceBtn');
+  for (const [i, button] of buttons.entries()) {
+    button.disabled = true;
+    if (i === state.correctIndex) button.classList.add('is-correct');
+    else if (i === choiceIndex) button.classList.add('is-wrong');
   }
-  window.forgeQuizTotalAnswered += 1;
-  state.answeredCount += 1;
-  const fx = forgeQuizTemplateEffectsFor(widget);
+}
+
+// Crédite le score/compteurs SI la réponse est bonne, puis déclenche
+// l'effet visuel du modèle actif (onCorrect/onWrong, voir static/js/play/
+// quiz-box-templates.js) — extrait de forgeQuizBoxAnswer.
+function applyQuizAnswerScoreAndEffect(widget, state, correct, fx) {
   if (correct) {
     window.forgeQuizCorrectAnswered += 1;
     state.correctCount += 1;
@@ -533,6 +528,11 @@ function forgeQuizBoxAnswer(quizObjectId, choiceIndex) {
   } else if (fx.onWrong) {
     fx.onWrong(widget);
   }
+}
+
+// xAPI + SCORM 2004 (cmi.interactions.n.*, no-op en SCORM 1.2/hors LMS) —
+// extrait de forgeQuizBoxAnswer.
+function notifyQuizAnswerTelemetry(state, correct, choiceIndex) {
   if (typeof forgeXapiNotifyQuestionAnswered === 'function') {
     forgeXapiNotifyQuestionAnswered(
       state.dialogueId,
@@ -543,8 +543,6 @@ function forgeQuizBoxAnswer(quizObjectId, choiceIndex) {
       correct ? state.rewardAmount : 0,
     );
   }
-  // cmi.interactions.n.* (SCORM 2004 uniquement, voir scorm2004-api.js) :
-  // no-op en SCORM 1.2/hors LMS (forgeScorm2004Api y reste null).
   if (typeof forgeScorm2004NotifyQuestionAnswered === 'function') {
     forgeScorm2004NotifyQuestionAnswered(
       state.dialogueId,
@@ -556,19 +554,50 @@ function forgeQuizBoxAnswer(quizObjectId, choiceIndex) {
       state.correctIndex,
     );
   }
-  // RGAA/WCAG 2.2.1 (délai réglable) : avancait auparavant tout seul
-  // après un délai fixe (700ms/1400ms), jamais assez pour un lecteur
-  // lent ou un utilisateur de lecteur d'écran — l'avancée dépend
-  // maintenant uniquement d'un clic sur "Continuer →", jamais d'un
-  // minuteur. Le bouton existe déjà (posé désactivé par forgeShowQuizBox
-  // ci-dessus, TOUJOURS visible — demande explicite, comme la maquette
-  // manga) : on se contente ici de l'ACTIVER, jamais de le recréer (ça
-  // effacerait le surlignage vert/rouge qu'on vient de poser sur les
-  // choix juste au-dessus).
-  if (widget) {
-    const continueBtnToEnable = widget.querySelector('.quizBoxContinueBtn');
-    if (continueBtnToEnable) continueBtnToEnable.disabled = false;
-  }
+}
+
+// RGAA/WCAG 2.2.1 (délai réglable) : avancait auparavant tout seul après
+// un délai fixe (700ms/1400ms), jamais assez pour un lecteur lent ou un
+// utilisateur de lecteur d'écran — l'avancée dépend maintenant
+// uniquement d'un clic sur "Continuer →", jamais d'un minuteur. Le
+// bouton existe déjà (posé désactivé par forgeShowQuizBox, TOUJOURS
+// visible — demande explicite, comme la maquette manga) : on se contente
+// ici de l'ACTIVER, jamais de le recréer (ça effacerait le surlignage
+// vert/rouge qu'on vient de poser sur les choix). Extrait de
+// forgeQuizBoxAnswer.
+function enableQuizContinueButton(widget) {
+  if (!widget) return;
+  const continueBtnToEnable = widget.querySelector('.quizBoxContinueBtn');
+  if (continueBtnToEnable) continueBtnToEnable.disabled = false;
+}
+
+// Appelée par le clic sur un choix (les boutons sont injectés EN JEU par
+// forgeShowQuizBox ci-dessus, jamais rendus côté serveur — voir
+// render_scene_object.py pour le seul aperçu statique de l'éditeur).
+// TOUJOURS crédite le score si la réponse est bonne PUIS avance à la
+// ligne suivante, QUE la réponse soit bonne ou mauvaise (demande
+// explicite : une mauvaise réponse ne doit jamais bloquer la
+// progression). Un second clic pendant cet affichage est ignoré
+// (`resolved`).
+function forgeQuizBoxAnswer(quizObjectId, choiceIndex) {
+  const state = forgeQuizBoxState[quizObjectId];
+  if (!state || state.resolved) return;
+  state.resolved = true;
+  const widget = forgeQuizBoxWidgetById(quizObjectId);
+  const correct = choiceIndex === state.correctIndex;
+  // Minuteur "par question" : cette question est résolue (bonne réponse,
+  // mauvaise réponse, OU minuteur expiré via forgeQuizBoxTimeout, qui
+  // appelle CETTE fonction avec choiceIndex=-1) — jamais le minuteur
+  // "pour tout le quiz", qui doit continuer à tourner sans interruption
+  // d'une question à l'autre.
+  if (widget?.dataset.timerMode === 'question') forgeStopQuizTimer(quizObjectId);
+  markQuizChoiceButtons(widget, state, choiceIndex);
+  window.forgeQuizTotalAnswered += 1;
+  state.answeredCount += 1;
+  const fx = forgeQuizTemplateEffectsFor(widget);
+  applyQuizAnswerScoreAndEffect(widget, state, correct, fx);
+  notifyQuizAnswerTelemetry(state, correct, choiceIndex);
+  enableQuizContinueButton(widget);
 }
 
 // Prépare l'écran de résultat de fin de quiz (voir static/js/play/
@@ -595,7 +624,7 @@ function forgeQuizPrepareResultScreen(quizObjectId, widget, state, forceEnd) {
   const { answeredCount } = state;
   return function () {
     widget.classList.add('is-active');
-    if (widget.getAttribute('data-fullscreen') === '1') widget.classList.add('is-fullscreen');
+    if (widget.dataset.fullscreen === '1') widget.classList.add('is-fullscreen');
     completeFx(widget, { correctCount, totalCount: answeredCount });
   };
 }
diff --git a/static/js/play/offline/__tests__/filter-repeater-rows.test.js b/static/js/play/offline/__tests__/filter-repeater-rows.test.js
index 870608b9..cdbbe5bb 100644
--- a/static/js/play/offline/__tests__/filter-repeater-rows.test.js
+++ b/static/js/play/offline/__tests__/filter-repeater-rows.test.js
@@ -111,3 +111,25 @@ test('forgeDecodeClauses — format JSON illimité prioritaire sur le legacy', (
   assert.equal(decoded.clauses.length, 1);
   assert.equal(decoded.combinator, 'ou');
 });
+
+test('forgeDecodeClauses — _filtres_json invalide : avertit en console, retombe sur le legacy sans planter (bug S2486 : exception avalée en silence auparavant)', () => {
+  const attrs = {
+    _filtres_json: '{not valid json',
+    _filtre_champ: 'pv',
+    _filtre_operateur: 'superieur_egal',
+    _filtre_valeur: '10',
+  };
+  const originalWarn = console.warn;
+  const warnCalls = [];
+  console.warn = (...args) => { warnCalls.push(args); };
+  try {
+    const decoded = forgeDecodeClauses(attrs, '_filtres_json', '_filtre_combinateur', '_filtre');
+    assert.equal(warnCalls.length, 1);
+    assert.match(warnCalls[0][0], /_filtres_json invalide/);
+    // Repli sur l'ancien format à 2 filtres fixes, comme avant ce fix.
+    assert.equal(decoded.clauses.length, 1);
+    assert.equal(decoded.clauses[0].champ, 'pv');
+  } finally {
+    console.warn = originalWarn;
+  }
+});
diff --git a/static/js/play/offline/__tests__/render-special-widgets.test.js b/static/js/play/offline/__tests__/render-special-widgets.test.js
index 1399d12f..b54d96a5 100644
--- a/static/js/play/offline/__tests__/render-special-widgets.test.js
+++ b/static/js/play/offline/__tests__/render-special-widgets.test.js
@@ -136,6 +136,121 @@ test('jauge — pourcentage et couleur interpolée depuis un champ d\'objet', ()
   assert.ok(html.includes('jaugeBar'));
 });
 
+// Couverture des branches d'afficherValeur/fieldNameNom AVANT le refactor
+// S3776 (24 -> lot 4 "modernisation JS") — pour garantir que l'extraction
+// en sous-fonctions ne change aucun comportement.
+test('jauge — _afficher_valeur affiche la valeur brute du champ dans un label superposé', () => {
+  const el = {
+    id: 10,
+    widget: 'jauge',
+    style: {},
+    attributes: {
+      _definition_id: '1', _champ: 'points', _min: '0', _max: '100', _afficher_valeur: '1',
+    },
+  };
+  const html = forgeRenderElementHtml(el, baseGameData(), {}, {});
+  assert.ok(html.includes('>42</div>'));
+});
+
+test('jauge — _afficher_valeur sans valeur trouvée (champ inconnu) affiche un tiret cadratin, pas "null"/"undefined"', () => {
+  const el = {
+    id: 10,
+    widget: 'jauge',
+    style: {},
+    attributes: {
+      _definition_id: '1', _champ: 'champ_qui_n_existe_pas', _min: '0', _max: '100', _afficher_valeur: '1',
+    },
+  };
+  const html = forgeRenderElementHtml(el, baseGameData(), {}, {});
+  assert.ok(html.includes('>—</div>'));
+});
+
+test('jauge — _row_id sélectionne une ligne précise (pas la plus récente)', () => {
+  const el = {
+    id: 10,
+    widget: 'jauge',
+    style: {},
+    attributes: {
+      _definition_id: '1', _champ: 'points', _row_id: '2', _min: '0', _max: '100',
+    },
+  };
+  const html = forgeRenderElementHtml(el, baseGameData(), {}, {});
+  assert.ok(html.includes('value="7"')); // ligne id=2 (Bob, points=7), pas la plus récente (Alice)
+});
+
+test('jauge — _champ_nom affiche un label avec le nom, aligné à gauche seulement en position "dessus"+"gauche"', () => {
+  const elGauche = {
+    id: 10,
+    widget: 'jauge',
+    style: {},
+    attributes: {
+      _definition_id: '1',
+      _champ: 'points',
+      _champ_nom: 'nom',
+      _min: '0',
+      _max: '100',
+      _nom_position: 'dessus',
+      _nom_alignement: 'gauche',
+      _nom_gras: '1',
+      _nom_italique: '1',
+    },
+  };
+  const htmlGauche = forgeRenderElementHtml(elGauche, baseGameData(), {}, {});
+  assert.ok(htmlGauche.includes('text-align:left'));
+  assert.ok(htmlGauche.includes('font-weight:700'));
+  assert.ok(htmlGauche.includes('font-style:italic'));
+  assert.ok(htmlGauche.includes('>Alice</div>'));
+
+  const elCote = {
+    id: 11,
+    widget: 'jauge',
+    style: {},
+    attributes: {
+      _definition_id: '1', _champ: 'points', _champ_nom: 'nom', _min: '0', _max: '100', _nom_position: 'cote',
+    },
+  };
+  const htmlCote = forgeRenderElementHtml(elCote, baseGameData(), {}, {});
+  assert.ok(htmlCote.includes('text-align:center'));
+  assert.ok(htmlCote.includes('flex-direction:row')); // "cote" bascule aussi la disposition générale
+});
+
+test('jauge — _champ_nom sans valeur trouvée (ligne/champ vide) : aucun label de nom généré', () => {
+  const el = {
+    id: 10,
+    widget: 'jauge',
+    style: {},
+    attributes: {
+      _definition_id: '1', _champ: 'points', _champ_nom: 'champ_qui_n_existe_pas', _min: '0', _max: '100',
+    },
+  };
+  const html = forgeRenderElementHtml(el, baseGameData(), {}, {});
+  assert.ok(!html.includes('text-align'));
+});
+
+test('jauge — classe CSS supplémentaire (_class_*) fusionnée sur la barre', () => {
+  const el = {
+    id: 10,
+    widget: 'jauge',
+    style: {},
+    attributes: {
+      _definition_id: '1', _champ: 'points', _min: '0', _max: '100', _class_extra: 'ma-classe',
+    },
+  };
+  const html = forgeRenderElementHtml(el, baseGameData(), {}, {});
+  assert.match(html, /class="progress jaugeBar ma-classe"/);
+});
+
+test('jauge — min/max absents retombent sur 0/100, valeur non numérique retombe sur min', () => {
+  const el = {
+    id: 10,
+    widget: 'jauge',
+    style: {},
+    attributes: { _definition_id: '1', _champ: 'nom' }, // "nom" = texte, pas un nombre
+  };
+  const html = forgeRenderElementHtml(el, baseGameData(), {}, {});
+  assert.ok(html.includes('value="0"')); // valeur non numérique -> repli sur min (0 par défaut)
+});
+
 test('répéteur — une repeaterItem par ligne, {{champ}} substitué', () => {
   const el = {
     id: 11,
diff --git a/static/js/play/offline/compute-operation.js b/static/js/play/offline/compute-operation.js
index 7c0dc380..5e1551d6 100644
--- a/static/js/play/offline/compute-operation.js
+++ b/static/js/play/offline/compute-operation.js
@@ -18,53 +18,82 @@ function forgePyMod(a, b) {
   return ((a % b) + b) % b;
 }
 
+function computeDefinirNombre(rawValue, round) {
+  const n = Number.parseFloat(rawValue);
+  return Number.isNaN(n) ? 0 : round(n);
+}
+
+// Partagée entre "incrementer" et "decrementer" (même calcul, signe
+// inversé) — extrait de forgeComputeNewValue (lot 4 "modernisation JS", S3776).
+function computeIncrementerOuDecrementer(operation, current, rawValue, round) {
+  let amount = (rawValue === null || rawValue === undefined || rawValue === '') ? 0 : Number.parseFloat(rawValue);
+  if (Number.isNaN(amount)) amount = 0;
+  if (operation === 'decrementer') amount = -amount;
+  return round((current || 0) + amount);
+}
+
+function computeMultiplier(current, rawValue, round) {
+  let factor = (rawValue === null || rawValue === undefined || rawValue === '') ? 1 : Number.parseFloat(rawValue);
+  if (Number.isNaN(factor)) factor = 1;
+  return round((current || 0) * factor);
+}
+
+// Partagée entre "diviser" et "modulo" — extrait de forgeComputeNewValue.
+function computeDiviserOuModulo(operation, current, rawValue, round) {
+  let divisor = (rawValue === null || rawValue === undefined || rawValue === '') ? 0 : Number.parseFloat(rawValue);
+  if (Number.isNaN(divisor)) divisor = 0;
+  if (divisor === 0) return current;
+  const result = operation === 'diviser' ? (current || 0) / divisor : forgePyMod(current || 0, divisor);
+  return round(result);
+}
+
+// Partagée entre "minimum" et "maximum" — extrait de forgeComputeNewValue.
+function computeMinimumOuMaximum(operation, current, rawValue, round) {
+  const bound = Number.parseFloat(rawValue);
+  if (Number.isNaN(bound)) return current;
+  const res = operation === 'minimum' ? Math.max(current || 0, bound) : Math.min(current || 0, bound);
+  return round(res);
+}
+
+function computeAlea(rawValue, isDecimal) {
+  const parts = String(rawValue || '').split(',');
+  let lo = Number.parseFloat(parts[0]); let
+    hi = Number.parseFloat(parts[1]);
+  if (Number.isNaN(lo)) lo = 0;
+  if (Number.isNaN(hi)) hi = 0;
+  if (lo > hi) { const tmp = lo; lo = hi; hi = tmp; }
+  if (isDecimal) return Math.random() * (hi - lo) + lo; // NOSONAR S2245 - tirage de jeu, jamais crypto
+  const iLo = Math.trunc(lo); const
+    iHi = Math.trunc(hi);
+  return Math.floor(Math.random() * (iHi - iLo + 1)) + iLo; // NOSONAR S2245 - tirage de jeu, jamais crypto
+}
+
+// Dispatch par nom d'opération — chaque fonction ci-dessus reçoit déjà
+// tout ce dont elle a besoin (current/rawValue/round/isDecimal), ce
+// dispatcher n'a donc plus qu'une seule décision (présence d'un
+// handler), au lieu d'empiler ici les conditions de chaque branche (même
+// méthode que runActionNode, static/js/play/actions.js).
+const OPERATION_HANDLERS = {
+  definir_texte: (current, rawValue) => rawValue || '',
+  definir_nombre: (current, rawValue, round) => computeDefinirNombre(rawValue, round),
+  definir_bool_vrai: () => 1,
+  definir_bool_faux: () => 0,
+  basculer_bool: (current) => (current ? 0 : 1),
+  incrementer: (current, rawValue, round) => computeIncrementerOuDecrementer('incrementer', current, rawValue, round),
+  decrementer: (current, rawValue, round) => computeIncrementerOuDecrementer('decrementer', current, rawValue, round),
+  multiplier: (current, rawValue, round) => computeMultiplier(current, rawValue, round),
+  diviser: (current, rawValue, round) => computeDiviserOuModulo('diviser', current, rawValue, round),
+  modulo: (current, rawValue, round) => computeDiviserOuModulo('modulo', current, rawValue, round),
+  minimum: (current, rawValue, round) => computeMinimumOuMaximum('minimum', current, rawValue, round),
+  maximum: (current, rawValue, round) => computeMinimumOuMaximum('maximum', current, rawValue, round),
+  alea: (current, rawValue, round, isDecimal) => computeAlea(rawValue, isDecimal),
+};
+
 function forgeComputeNewValue(operation, current, rawValue, isDecimal) {
   const round = function (v) { return isDecimal ? v : forgePyInt(v); };
-  if (operation === 'definir_texte') return rawValue || '';
-  if (operation === 'definir_nombre') {
-    const n = parseFloat(rawValue);
-    return Number.isNaN(n) ? 0 : round(n);
-  }
-  if (operation === 'definir_bool_vrai') return 1;
-  if (operation === 'definir_bool_faux') return 0;
-  if (operation === 'basculer_bool') return current ? 0 : 1;
-  if (operation === 'incrementer' || operation === 'decrementer') {
-    let amount = (rawValue === null || rawValue === undefined || rawValue === '') ? 0 : parseFloat(rawValue);
-    if (Number.isNaN(amount)) amount = 0;
-    if (operation === 'decrementer') amount = -amount;
-    return round((current || 0) + amount);
-  }
-  if (operation === 'multiplier') {
-    let factor = (rawValue === null || rawValue === undefined || rawValue === '') ? 1 : parseFloat(rawValue);
-    if (Number.isNaN(factor)) factor = 1;
-    return round((current || 0) * factor);
-  }
-  if (operation === 'diviser' || operation === 'modulo') {
-    let divisor = (rawValue === null || rawValue === undefined || rawValue === '') ? 0 : parseFloat(rawValue);
-    if (Number.isNaN(divisor)) divisor = 0;
-    if (divisor === 0) return current;
-    const result = operation === 'diviser' ? (current || 0) / divisor : forgePyMod(current || 0, divisor);
-    return round(result);
-  }
-  if (operation === 'minimum' || operation === 'maximum') {
-    const bound = parseFloat(rawValue);
-    if (Number.isNaN(bound)) return current;
-    const res = operation === 'minimum' ? Math.max(current || 0, bound) : Math.min(current || 0, bound);
-    return round(res);
-  }
-  if (operation === 'alea') {
-    const parts = String(rawValue || '').split(',');
-    let lo = parseFloat(parts[0]); let
-      hi = parseFloat(parts[1]);
-    if (Number.isNaN(lo)) lo = 0;
-    if (Number.isNaN(hi)) hi = 0;
-    if (lo > hi) { const tmp = lo; lo = hi; hi = tmp; }
-    if (isDecimal) return Math.random() * (hi - lo) + lo; // NOSONAR S2245 - tirage de jeu, jamais crypto
-    const iLo = Math.trunc(lo); const
-      iHi = Math.trunc(hi);
-    return Math.floor(Math.random() * (iHi - iLo + 1)) + iLo; // NOSONAR S2245 - tirage de jeu, jamais crypto
-  }
-  throw new Error(`opération inconnue : ${operation}`);
+  const handler = OPERATION_HANDLERS[operation];
+  if (!handler) throw new Error(`opération inconnue : ${operation}`);
+  return handler(current, rawValue, round, isDecimal);
 }
 
 // static/js/play/__tests__/ (node:test) — même patron que conditions.js.
diff --git a/static/js/play/offline/filter-repeater-rows.js b/static/js/play/offline/filter-repeater-rows.js
index 6b1e4e4a..79eeaffa 100644
--- a/static/js/play/offline/filter-repeater-rows.js
+++ b/static/js/play/offline/filter-repeater-rows.js
@@ -21,7 +21,15 @@ function forgeDecodeClauses(attrs, clausesAttr, combinatorAttr, legacyPrefix) {
     try {
       const parsed = JSON.parse(raw);
       if (Array.isArray(parsed)) clauses = parsed;
-    } catch (e) { clauses = null; }
+    } catch (e) {
+      // Signalement devtools uniquement (voir CODE_QUALITY.md, S2486) :
+      // _filtres_json est produit par le rendu serveur, jamais tapé à la
+      // main — un JSON invalide ici trahit presque toujours un bug côté
+      // éditeur/serveur. Comportement inchangé : repli sur l'ancien
+      // format ou aucun filtre, comme avant.
+      console.warn('_filtres_json invalide, filtre ignoré', e);
+      clauses = null;
+    }
   }
   if (clauses === null && legacyPrefix) {
     clauses = [];
@@ -48,7 +56,7 @@ function forgeResolveVariablePath(rawValue, path) {
   let current;
   try {
     current = rawValue ? JSON.parse(rawValue) : null;
-  } catch (e) {
+  } catch (e) { // NOSONAR S2486 - variable pas au format JSON, cas normal (voir commentaire de la fonction)
     return null;
   }
   let m;
@@ -57,9 +65,9 @@ function forgeResolveVariablePath(rawValue, path) {
     const key = m[1]; const
       index = m[2];
     try {
-      current = key !== undefined ? current[key] : current[parseInt(index, 10)];
+      current = key !== undefined ? current[key] : current[Number.parseInt(index, 10)];
       if (current === undefined) return null;
-    } catch (e) {
+    } catch (e) { // NOSONAR S2486 - chemin qui ne correspond pas a la forme actuelle de la variable, cas normal
       return null;
     }
   }
@@ -91,7 +99,7 @@ function forgeResolveFilterValue(gameData, rawValue) {
 
   const varMatch = FORGE_VAR_REF_PATTERN.exec(stripped);
   if (varMatch) {
-    const variable = gameData.variables && gameData.variables[varMatch[1].trim()];
+    const variable = gameData.variables?.[varMatch[1].trim()];
     if (!variable) return null; // variable supprimée depuis : ne matche rien plutôt que planter
     return forgeResolveVariablePath(variable.value, varMatch[2]);
   }
@@ -103,8 +111,8 @@ function forgeResolveFilterValue(gameData, rawValue) {
   const names = gameData.definition_names || {};
   for (const defId in names) {
     if (names[defId] === objectName) {
-      const rows = gameData.data && gameData.data[defId];
-      if (rows && rows.length) {
+      const rows = gameData.data?.[defId];
+      if (rows?.length) {
         return rows[0][fieldName];
       }
       return null;
@@ -119,7 +127,7 @@ function forgeClauseMatches(gameData, definitionId, row, clause) {
   if (!fieldName) return true;
   const operator = clause.operateur || 'egal';
   const expected = forgeResolveFilterValue(gameData, clause.valeur || '');
-  const fieldsMetaForDef = gameData.fields_meta && gameData.fields_meta[definitionId];
+  const fieldsMetaForDef = gameData.fields_meta?.[definitionId];
   const field = (fieldsMetaForDef || []).find((f) => f.name === fieldName);
   const fieldType = field ? field.type : 'texte';
   return compareValues(row[fieldName], operator, expected, fieldType);
@@ -127,7 +135,7 @@ function forgeClauseMatches(gameData, definitionId, row, clause) {
 
 // Port de filter_rows_by_clauses.
 function forgeFilterRowsByClauses(gameData, definitionId, rows, clauses, combinator) {
-  if (!clauses || !clauses.length) return rows;
+  if (!clauses?.length) return rows;
   if (combinator === 'ou') {
     return rows.filter((r) => clauses.some((c) => forgeClauseMatches(gameData, definitionId, r, c)));
   }
diff --git a/static/js/play/offline/render-element.js b/static/js/play/offline/render-element.js
index 9b8834cf..e94727fa 100644
--- a/static/js/play/offline/render-element.js
+++ b/static/js/play/offline/render-element.js
@@ -15,7 +15,7 @@
 // play.html) et sont routés depuis forgeRenderElementHtml() ci-dessous
 // via forgeSpecialRenderer().
 
-const FORGE_LAYOUT_CAPABLE_WIDGETS = ['conteneur', 'repeteur_donnees', 'liste', 'liste_numerotee', 'groupe_champs', 'tableau'];
+const FORGE_LAYOUT_CAPABLE_WIDGETS = new Set(['conteneur', 'repeteur_donnees', 'liste', 'liste_numerotee', 'groupe_champs', 'tableau']);
 
 // Widgets à balise simple portés à l'étape 3 — {tag, hasContent,
 // selfClosing, fixedAttrs} — port direct de screens/widgets/registry.py
@@ -66,9 +66,9 @@ const FORGE_SPECIAL_WIDGET_FIXED_ATTRS = { tableau: { class: 'table' } };
 
 function forgeHtmlEscape(s) {
   return String(s)
-    .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
-    .replace(/"/g, '&quot;')
-    .replace(/'/g, '&#x27;');
+    .replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&#x27;');
 }
 
 // Port de apply_ctx.py — {{champ}} remplacé par la valeur de la ligne en
@@ -89,7 +89,7 @@ function forgeAutoId(el) {
 
 // Port de parent_flex_direction.py.
 function forgeParentFlexDirection(parentEl) {
-  const style = (parentEl && parentEl.style) || {};
+  const style = parentEl?.style || {};
   if (style.display !== 'flex') return null;
   return style['flex-direction'] || 'row';
 }
@@ -99,8 +99,8 @@ function forgeParentFlexDirection(parentEl) {
 // enfant), même garde-fous (transform réservé au cadre extérieur pour un
 // élément posé directement sur l'écran, 0px ignoré = pas de surcharge).
 function forgeStyleString(el, parentFlexDirection, widgetKey) {
-  const style = { ...el.style || {} };
-  if (FORGE_LAYOUT_CAPABLE_WIDGETS.indexOf(widgetKey) !== -1 && !('display' in style)) {
+  const style = { ...el.style };
+  if (FORGE_LAYOUT_CAPABLE_WIDGETS.has(widgetKey) && !('display' in style)) {
     style.display = 'flex';
     if (!('flex-direction' in style)) style['flex-direction'] = 'column';
   }
@@ -150,13 +150,13 @@ function forgeVisibleAttrs(el, meta, ctx) {
   const rawAttrs = el.attributes || {};
   const attrs = {};
   Object.keys(rawAttrs).forEach((k) => {
-    if (k.indexOf('_') === 0) return;
+    if (k.startsWith('_')) return;
     const v = rawAttrs[k];
     attrs[k] = typeof v === 'string' ? forgeApplyCtx(v, ctx) : v;
   });
   Object.assign(attrs, meta.fixedAttrs || {});
   const extraClasses = Object.keys(rawAttrs)
-    .filter((k) => k.indexOf('_class_') === 0 && rawAttrs[k])
+    .filter((k) => k.startsWith('_class_') && rawAttrs[k])
     .map((k) => rawAttrs[k]);
   if (extraClasses.length) {
     const baseClass = attrs.class || '';
@@ -170,7 +170,7 @@ function forgeVisibleAttrs(el, meta, ctx) {
 
 // Port de render_children.py.
 function forgeRenderChildren(el, gameData, childrenMap, ctx) {
-  const kids = (childrenMap && childrenMap[el.id]) || [];
+  const kids = childrenMap?.[el.id] || [];
   const flexDir = forgeParentFlexDirection(el);
   return kids.map((c) => forgeRenderElementHtml(c, gameData, childrenMap, ctx, flexDir)).join('');
 }
@@ -182,9 +182,9 @@ function forgeResolveBoundRowCtx(gameData, attrs) {
   let definitionId = attrs._data_definition_id;
   if (!definitionId) return null;
   definitionId = String(definitionId);
-  const fieldsMetaForDef = gameData.fields_meta && gameData.fields_meta[definitionId];
+  const fieldsMetaForDef = gameData.fields_meta?.[definitionId];
   if (!fieldsMetaForDef) return null;
-  let rows = (gameData.data && gameData.data[definitionId]) || [];
+  let rows = gameData.data?.[definitionId] || [];
   const decoded = forgeDecodeClauses(attrs, '_data_filtres_json', '_data_filtre_combinateur', '_data_filtre');
   rows = forgeFilterRowsByClauses(gameData, definitionId, rows, decoded.clauses, decoded.combinator);
   if (!rows.length) return null;
@@ -206,8 +206,8 @@ function forgeResolveBoundRowCtx(gameData, attrs) {
 // une fois à l'export, voir full_game_payload.py) plutôt que depuis
 // d'éventuels enfants copiés en base.
 function forgeRenderElementTypeChildren(el, gameData, ctx) {
-  const templateTree = gameData.element_type_templates && gameData.element_type_templates[String(el.element_type_id)];
-  if (!templateTree || !templateTree.top.length) return [null, false];
+  const templateTree = gameData.element_type_templates?.[String(el.element_type_id)];
+  if (!templateTree?.top.length) return [null, false];
   const isOverlayOnly = templateTree.top.every((c) => c.widget === 'superposition');
   let { top } = templateTree;
   if (isOverlayOnly) {
@@ -255,7 +255,7 @@ function forgeRenderElementHtml(el, gameData, childrenMap, ctx, parentFlexDirect
   const attrsRaw = el.attributes || {};
 
   const hasVisibilityCondition = attrsRaw._visibilite_cond_mode === 'variable' || attrsRaw._visibilite_cond_mode === 'objet';
-  const playMode = !!((ctx || {})._forge_play_mode);
+  const playMode = !!ctx?._forge_play_mode;
   if (playMode && hasVisibilityCondition && !forgeIsElementVisibleOffline(gameData, attrsRaw, ctx)) {
     return `<div class="visibilityGated" data-element-id="${el.id}" style="display:none;"></div>`;
   }
@@ -268,7 +268,7 @@ function forgeRenderElementHtml(el, gameData, childrenMap, ctx, parentFlexDirect
   };
 
   const boundCtx = forgeResolveBoundRowCtx(gameData, attrsRaw);
-  if (boundCtx) ctx = { ...ctx || {}, ...boundCtx };
+  if (boundCtx) ctx = { ...ctx, ...boundCtx };
 
   // meta d'un widget à special_render : fixedAttrs propre (voir
   // screens/widgets/registry.py — seul "tableau" en a un, "class":"table"),
@@ -319,7 +319,7 @@ function forgeRenderElementHtml(el, gameData, childrenMap, ctx, parentFlexDirect
     return mark(`<${tag} ${forgeAttrString(attrs, style)}>${inner}</${tag}>`);
   }
 
-  const safeContent = content ? forgeHtmlEscape(content).replace(/\n/g, '<br>') : '';
+  const safeContent = content ? forgeHtmlEscape(content).replaceAll('\n', '<br>') : '';
   return mark(`<${tag} ${forgeAttrString(attrs, style)}>${safeContent}${childHtml}</${tag}>`);
 }
 
diff --git a/static/js/play/offline/render-jauge.js b/static/js/play/offline/render-jauge.js
index 6024bb31..3614e732 100644
--- a/static/js/play/offline/render-jauge.js
+++ b/static/js/play/offline/render-jauge.js
@@ -6,15 +6,25 @@
 function forgeHexToRgb(hexColor) {
   let hex = (hexColor || '#5b8cff').replace(/^#/, '');
   if (hex.length !== 6) hex = '5b8cff';
-  return [parseInt(hex.substr(0, 2), 16), parseInt(hex.substr(2, 2), 16), parseInt(hex.substr(4, 2), 16)];
+  return [
+    Number.parseInt(hex.substr(0, 2), 16),
+    Number.parseInt(hex.substr(2, 2), 16),
+    Number.parseInt(hex.substr(4, 2), 16),
+  ];
+}
+
+// Extrait de forgeInterpolateColor (lot 4 "modernisation JS", S7721) :
+// fonction pure (aucune fermeture sur lo/hi/mixed/ratio), pas besoin
+// d'être redéfinie à chaque appel.
+function forgeByteToHex(n) {
+  return n.toString(16).padStart(2, '0');
 }
 
 function forgeInterpolateColor(lowHex, highHex, ratio) {
   const lo = forgeHexToRgb(lowHex); const
     hi = forgeHexToRgb(highHex);
   const mixed = lo.map((c, i) => Math.round(c + (hi[i] - c) * ratio));
-  const toHex = function (n) { return n.toString(16).padStart(2, '0'); };
-  return `#${mixed.map(toHex).join('')}`;
+  return `#${mixed.map(forgeByteToHex).join('')}`;
 }
 
 // Port de _read_field_value — repli sur la ligne la PLUS RÉCENTE si
@@ -23,14 +33,42 @@ function forgeInterpolateColor(lowHex, highHex, ratio) {
 function forgeReadFieldValue(gameData, definitionId, rowId, fieldName) {
   if (!definitionId || !fieldName) return null;
   definitionId = String(definitionId);
-  const rows = gameData.data && gameData.data[definitionId];
-  if (!rows || !rows.length) return null;
+  const rows = gameData.data?.[definitionId];
+  if (!rows?.length) return null;
   let row = null;
   if (rowId) row = rows.find((r) => String(r.id) === String(rowId));
   if (!row) row = rows[0];
   return row[fieldName];
 }
 
+// Label superposé qui affiche la valeur BRUTE du champ (indépendant du
+// pourcentage/couleur) — extrait de forgeRenderJauge (lot 4 "modernisation
+// JS", S3776).
+function forgeJaugeValueLabelHtml(afficherValeur, rawValue) {
+  if (!afficherValeur) return '';
+  return '<div style="position:absolute; inset:0; display:flex; align-items:center; '
+    + 'justify-content:center; font-family:system-ui,sans-serif; font-size:12px; '
+    + `color:#e8eaf0; text-shadow:0 1px 2px rgba(0,0,0,.6);">${
+      forgeHtmlEscape(rawValue !== null && rawValue !== undefined ? String(rawValue) : '—')}</div>`;
+}
+
+// Label du NOM (ex. "Alice"), lu depuis un second champ optionnel — extrait
+// de forgeRenderJauge.
+function forgeJaugeNameLabelHtml(gameData, definitionId, rowId, fieldNameNom, nomPosition, nomAlignement, nomStyle) {
+  if (!fieldNameNom) return '';
+  const nomValue = forgeReadFieldValue(gameData, definitionId, rowId, fieldNameNom);
+  if (nomValue === null || nomValue === undefined || nomValue === '') return '';
+  const textAlign = (nomPosition === 'dessus' && nomAlignement === 'gauche') ? 'left' : 'center';
+  const {
+    nomPolice, nomTaille, nomGras, nomItalique,
+  } = nomStyle;
+  return `<div style="flex:0 0 auto; font-family:${forgeHtmlEscape(nomPolice)}; `
+    + `font-size:${forgeHtmlEscape(String(nomTaille))}px; `
+    + `font-weight:${nomGras ? '700' : '400'}; `
+    + `font-style:${nomItalique ? 'italic' : 'normal'}; `
+    + `color:#e8eaf0; text-align:${textAlign};">${forgeHtmlEscape(String(nomValue))}</div>`;
+}
+
 function forgeRenderJauge(el, meta, gameData, childrenMap, ctx, parentFlexDirection) {
   const attrs = el.attributes || {};
   const nomPosition = attrs._nom_position || 'dessus';
@@ -47,14 +85,14 @@ function forgeRenderJauge(el, meta, gameData, childrenMap, ctx, parentFlexDirect
   const rowId = attrs._row_id;
   const fieldName = (attrs._champ || '').trim();
   const fieldNameNom = (attrs._champ_nom || '').trim();
-  let minV = parseFloat(attrs._min); if (Number.isNaN(minV)) minV = 0;
-  let maxV = parseFloat(attrs._max); if (Number.isNaN(maxV)) maxV = 100;
+  let minV = Number.parseFloat(attrs._min); if (Number.isNaN(minV)) minV = 0;
+  let maxV = Number.parseFloat(attrs._max); if (Number.isNaN(maxV)) maxV = 100;
   const couleurBasse = attrs._couleur_basse || '#e05252';
   const couleurHaute = attrs._couleur_haute || '#4caf50';
   const afficherValeur = attrs._afficher_valeur === '1';
 
   const rawValue = fieldName ? forgeReadFieldValue(gameData, definitionId, rowId, fieldName) : null;
-  let value = parseFloat(rawValue);
+  let value = Number.parseFloat(rawValue);
   if (Number.isNaN(value)) value = minV;
 
   const span = (maxV - minV) || 1;
@@ -62,29 +100,22 @@ function forgeRenderJauge(el, meta, gameData, childrenMap, ctx, parentFlexDirect
   const percent = Math.round(ratio * 1000) / 10;
   const fillColor = forgeInterpolateColor(couleurBasse, couleurHaute, ratio);
 
-  let labelHtml = '';
-  if (afficherValeur) {
-    labelHtml = '<div style="position:absolute; inset:0; display:flex; align-items:center; '
-      + 'justify-content:center; font-family:system-ui,sans-serif; font-size:12px; '
-      + `color:#e8eaf0; text-shadow:0 1px 2px rgba(0,0,0,.6);">${
-        forgeHtmlEscape(rawValue !== null && rawValue !== undefined ? String(rawValue) : '—')}</div>`;
-  }
-
-  let nameHtml = '';
-  if (fieldNameNom) {
-    const nomValue = forgeReadFieldValue(gameData, definitionId, rowId, fieldNameNom);
-    if (nomValue !== null && nomValue !== undefined && nomValue !== '') {
-      const textAlign = (nomPosition === 'dessus' && nomAlignement === 'gauche') ? 'left' : 'center';
-      nameHtml = `<div style="flex:0 0 auto; font-family:${forgeHtmlEscape(nomPolice)}; `
-        + `font-size:${forgeHtmlEscape(String(nomTaille))}px; `
-        + `font-weight:${nomGras ? '700' : '400'}; `
-        + `font-style:${nomItalique ? 'italic' : 'normal'}; `
-        + `color:#e8eaf0; text-align:${textAlign};">${forgeHtmlEscape(String(nomValue))}</div>`;
-    }
-  }
+  const labelHtml = forgeJaugeValueLabelHtml(afficherValeur, rawValue);
+  const nomStyle = {
+    nomPolice, nomTaille, nomGras, nomItalique,
+  };
+  const nameHtml = forgeJaugeNameLabelHtml(
+    gameData,
+    definitionId,
+    rowId,
+    fieldNameNom,
+    nomPosition,
+    nomAlignement,
+    nomStyle,
+  );
 
   const extraClasses = Object.keys(attrs)
-    .filter((k) => k.indexOf('_class_') === 0 && attrs[k])
+    .filter((k) => k.startsWith('_class_') && attrs[k])
     .map((k) => attrs[k]).join(' ');
   const barClass = forgeHtmlEscape((`progress jaugeBar ${extraClasses}`).trim());
   const bar = `<progress class="${barClass}" value="${percent}" max="100" `
diff --git a/static/js/play/offline/render-overlay.js b/static/js/play/offline/render-overlay.js
index 0958000e..94162eee 100644
--- a/static/js/play/offline/render-overlay.js
+++ b/static/js/play/offline/render-overlay.js
@@ -4,7 +4,7 @@
 // dans l'éditeur (non pertinent hors ligne, qui ne sert jamais l'éditeur,
 // mais le port reste fidèle pour ne pas diverger inutilement).
 function forgeRenderOverlay(el, meta, gameData, childrenMap, ctx, parentFlexDirection) {
-  const isPlayMode = !!(ctx && ctx._forge_play_mode);
+  const isPlayMode = !!ctx?._forge_play_mode;
   const attrsRaw = el.attributes || {};
   const boxColor = attrsRaw._couleur_boite || '#1f2430';
   const radius = attrsRaw._arrondi || '12';
diff --git a/static/js/play/offline/render-repeater.js b/static/js/play/offline/render-repeater.js
index 981f2817..29792304 100644
--- a/static/js/play/offline/render-repeater.js
+++ b/static/js/play/offline/render-repeater.js
@@ -10,14 +10,14 @@ function forgeRenderRepeater(el, meta, gameData, childrenMap, ctx, parentFlexDir
   const definitionAttr = definitionId ? ` data-definition-id="${forgeHtmlEscape(String(definitionId))}"` : '';
   const templateTypeId = attrsRaw._template_type_id;
   const template = forgeApplyCtx(el.content || '', ctx);
-  const children = (childrenMap && childrenMap[el.id]) || [];
+  const children = childrenMap?.[el.id] || [];
 
   if (!definitionId) {
     return `<div id="${forgeAutoId(el)}" data-element-id="${el.id}" style="${forgeHtmlEscape(style)
     }"><em>Répéteur : choisis un objet de données dans les propriétés.</em></div>`;
   }
   definitionId = String(definitionId);
-  const fieldsMetaForDef = gameData.fields_meta && gameData.fields_meta[definitionId];
+  const fieldsMetaForDef = gameData.fields_meta?.[definitionId];
   if (!fieldsMetaForDef) {
     return `<div id="${forgeAutoId(el)}" data-element-id="${el.id}" style="${forgeHtmlEscape(style)
     }"><em>Objet introuvable — a-t-il été supprimé ?</em></div>`;
@@ -28,11 +28,11 @@ function forgeRenderRepeater(el, meta, gameData, childrenMap, ctx, parentFlexDir
 
   let templateTree = null;
   if (templateTypeId) {
-    templateTree = gameData.element_type_templates && gameData.element_type_templates[String(templateTypeId)];
+    templateTree = gameData.element_type_templates?.[String(templateTypeId)];
   }
 
   const items = rows.map((row) => {
-    const rowCtx = { ...ctx || {} };
+    const rowCtx = { ...ctx };
     // gameData.data est déjà indexé par le nom D'AFFICHAGE du champ (voir
     // full_game_payload.py), jamais par sa colonne SQL — row[f.name] lit
     // donc directement la bonne valeur, y compris pour un champ "relation"
diff --git a/static/js/play/offline/render-special-widgets.js b/static/js/play/offline/render-special-widgets.js
index 6b15a909..b432f9d1 100644
--- a/static/js/play/offline/render-special-widgets.js
+++ b/static/js/play/offline/render-special-widgets.js
@@ -48,7 +48,7 @@ function forgeRenderFieldset(el, meta, gameData, childrenMap, ctx, parentFlexDir
 
 function forgeRenderTable(el, meta, gameData, childrenMap, ctx, parentFlexDirection) {
   const attrs = forgeVisibleAttrs(el, meta, ctx);
-  const headerRow = ['1', 'true', 'on'].indexOf((el.attributes || {})._header_row) !== -1;
+  const headerRow = ['1', 'true', 'on'].includes(el.attributes?._header_row);
   const content = forgeApplyCtx(el.content || '', ctx);
   const style = forgeStyleString(el, parentFlexDirection, el.widget);
   const rows = content.split('\n').filter((r) => r.trim());
@@ -83,7 +83,7 @@ function forgeRenderIcone(el, meta, gameData, childrenMap, ctx, parentFlexDirect
   // devrait pas arriver : _collect_icon_slugs scanne tous les widgets
   // "icone", posés directement ou nichés dans un élément de jeu
   // réutilisable) — au moins un lien exploitable plutôt qu'un vide.
-  const iconUrl = (gameData.icon_data_uris && gameData.icon_data_uris[iconSlug]) || (`icons/${iconSlug}.svg`);
+  const iconUrl = gameData.icon_data_uris?.[iconSlug] || (`icons/${iconSlug}.svg`);
   const style = `${forgeStyleString(el, parentFlexDirection, el.widget)} --icon-url:url('${iconUrl}');`;
   // aria-hidden (RGAA/WCAG 1.1.1) : une icône seule (pas de champ de
   // description dédié dans l'éditeur) est traitée comme purement
@@ -94,7 +94,7 @@ function forgeRenderIcone(el, meta, gameData, childrenMap, ctx, parentFlexDirect
 }
 
 function forgeRenderOnglets(el, meta, gameData, childrenMap, ctx, parentFlexDirection) {
-  const tabs = (childrenMap && childrenMap[el.id]) || [];
+  const tabs = childrenMap?.[el.id] || [];
   const attrs = forgeVisibleAttrs(el, meta, ctx);
   const tabsExtraClasses = attrs.class || '';
   delete attrs.class;
@@ -138,9 +138,9 @@ function forgeRenderOnglets(el, meta, gameData, childrenMap, ctx, parentFlexDire
 function forgeRenderPersonnage(el, meta, gameData, childrenMap, ctx, parentFlexDirection) {
   const attrs = forgeVisibleAttrs(el, meta, ctx);
   attrs['data-personnage'] = '1';
-  const animations = gameData.personnage_animations && gameData.personnage_animations[String(el.id)];
+  const animations = gameData.personnage_animations?.[String(el.id)];
   const frames = animations ? (animations.idle || animations[Object.keys(animations)[0]]) : null;
-  const idleFrame = frames && frames.length ? frames[0] : '';
+  const idleFrame = frames?.length ? frames[0] : '';
   if (idleFrame) attrs.src = idleFrame;
   // alt (RGAA/WCAG 1.1.1) : voir render-element.js pour le même défaut
   // décoratif sur le widget "image" générique.
diff --git a/static/js/play/personnage-controller.js b/static/js/play/personnage-controller.js
index 5ce27e77..a2447bb9 100644
--- a/static/js/play/personnage-controller.js
+++ b/static/js/play/personnage-controller.js
@@ -21,8 +21,8 @@ let activePersonnageInteractListener = null;
 const FORGE_PERSONNAGE_FPS = 8;
 
 function forgePersonnageAnimExists(elementId, animName) {
-  const byAnim = (gameData.personnage_animations || {})[elementId];
-  return !!(byAnim && byAnim[animName] && byAnim[animName].length);
+  const byAnim = gameData.personnage_animations?.[elementId];
+  return !!byAnim?.[animName]?.length;
 }
 
 // "walk" est la SEULE animation de déplacement du catalogue Forge/CraftPix
@@ -81,10 +81,10 @@ function forgeUpdateSceneCamera(screenData) {
   const player = (screenData.elements || []).find((o) => o.kind === 'personnage' && o.personnage_role === 'joueur');
   const playerEl = player && document.querySelector(`[data-object-id="${player.id}"]`);
   const px = playerEl
-    ? (parseFloat(playerEl.style.left) || 0) + (parseFloat(playerEl.style.width) || 0) / 2
+    ? (Number.parseFloat(playerEl.style.left) || 0) + (Number.parseFloat(playerEl.style.width) || 0) / 2
     : world.width / 2;
   const py = playerEl
-    ? (parseFloat(playerEl.style.top) || 0) + (parseFloat(playerEl.style.height) || 0) / 2
+    ? (Number.parseFloat(playerEl.style.top) || 0) + (Number.parseFloat(playerEl.style.height) || 0) / 2
     : world.height / 2;
   const offsetX = Math.min(
     Math.max(px - screenData.scene_width / 2, 0),
@@ -125,7 +125,7 @@ function forgeObjectCollisionRectAt(left, top, width, height, collision) {
 // objet dont la collision est explicitement désactivée, ni l'objet qui
 // se déplace lui-même.
 function forgeSolidObstacles(screenData, movingId) {
-  return (screenData.elements || []).filter((o) => o.id !== movingId && o.kind !== 'fond' && o.kind !== 'dialogue_box' && o.kind !== 'quiz_box' && o.kind !== 'score_widget' && !(o.collision && o.collision.enabled === false));
+  return (screenData.elements || []).filter((o) => o.id !== movingId && o.kind !== 'fond' && o.kind !== 'dialogue_box' && o.kind !== 'quiz_box' && o.kind !== 'score_widget' && o.collision?.enabled !== false);
 }
 
 // Est-ce que le personnage, À la position candidate (newLeft/newTop),
@@ -139,90 +139,118 @@ function forgeSolidObstacles(screenData, movingId) {
 function forgeWouldCollide(screenData, movingObj, newLeft, newTop, width, height) {
   const movingRect = forgeObjectCollisionRectAt(newLeft, newTop, width, height, movingObj.collision);
   const obstacles = forgeSolidObstacles(screenData, movingObj.id);
-  for (let i = 0; i < obstacles.length; i++) {
-    const other = obstacles[i];
+  for (const other of obstacles) {
     const otherEl = document.querySelector(`[data-object-id="${other.id}"]`);
     if (!otherEl) continue;
-    const otherLeft = parseFloat(otherEl.style.left) || 0;
-    const otherTop = parseFloat(otherEl.style.top) || 0;
-    const otherWidth = parseFloat(otherEl.style.width) || 0;
-    const otherHeight = parseFloat(otherEl.style.height) || 0;
+    const otherLeft = Number.parseFloat(otherEl.style.left) || 0;
+    const otherTop = Number.parseFloat(otherEl.style.top) || 0;
+    const otherWidth = Number.parseFloat(otherEl.style.width) || 0;
+    const otherHeight = Number.parseFloat(otherEl.style.height) || 0;
     const otherRect = forgeObjectCollisionRectAt(otherLeft, otherTop, otherWidth, otherHeight, other.collision);
     if (forgeShapesOverlap(movingRect, otherRect)) return true;
   }
   return false;
 }
 
+// Déplacement BRUT tenté (avant collision), selon l'axe autorisé par cmd.axe
+// — extrait de forgeRunPersonnageControllerTick (lot 4 "modernisation JS", S3776).
+function forgeComputeMovementDelta(cmd) {
+  let rawDx = 0; let
+    rawDy = 0;
+  if (cmd.axe !== 'vertical') {
+    if (heldKeys.has(cmd.gauche)) rawDx -= cmd.vitesse;
+    if (heldKeys.has(cmd.droite)) rawDx += cmd.vitesse;
+  }
+  if (cmd.axe !== 'horizontal') {
+    if (heldKeys.has(cmd.haut)) rawDy -= cmd.vitesse;
+    if (heldKeys.has(cmd.bas)) rawDy += cmd.vitesse;
+  }
+  return { rawDx, rawDy };
+}
+
+// Bloque le déplacement axe par axe (pas les deux à la fois dès qu'un seul
+// est gêné) — glisser le long d'un mur en diagonale reste possible, plus
+// naturel qu'un blocage total au moindre contact. Extrait de
+// forgeRunPersonnageControllerTick.
+// `box` = {left, top, width, height} (position/taille ACTUELLES, avant
+// déplacement) ; `rawDelta` = {rawDx, rawDy} (voir forgeComputeMovementDelta)
+// — regroupés en objets pour rester sous la limite de 7 paramètres (S107),
+// plutôt que 9 paramètres positionnels distincts.
+function forgeResolveBlockedMovement(screenData, obj, targetEl, box, rawDelta) {
+  const {
+    left: curLeft, top: curTop, width: boxWidth, height: boxHeight,
+  } = box;
+  let { rawDx: dx, rawDy: dy } = rawDelta;
+  if (dx !== 0) {
+    const candidateLeft = clampSceneObjectPosition(targetEl, 'left', curLeft + dx);
+    if (forgeWouldCollide(screenData, obj, candidateLeft, curTop, boxWidth, boxHeight)) dx = 0;
+  }
+  if (dy !== 0) {
+    const candidateTop = clampSceneObjectPosition(targetEl, 'top', curTop + dy);
+    if (forgeWouldCollide(screenData, obj, curLeft, candidateTop, boxWidth, boxHeight)) dy = 0;
+  }
+  return { dx, dy };
+}
+
+// Anime idle (immobile) ou walk (déplacement effectif) — même fps pour les
+// deux (bug corrigé par l'utilisateur : idle tournait à 4 i/s contre 8
+// pour walk, aucune raison réelle de les désynchroniser). Extrait de
+// forgeRunPersonnageControllerTick.
+function forgeApplyPersonnageAnimForTick(targetEl, obj, dx, dy) {
+  if (dx === 0 && dy === 0) {
+    const idleAnim = forgePersonnageIdleAnim(obj.id);
+    if (idleAnim) {
+      runSpriteAnimation(
+        targetEl,
+        resolveSpriteFrames(obj.id, { animation: idleAnim, fps: FORGE_PERSONNAGE_FPS, loop: true }),
+      );
+    }
+    return;
+  }
+  const moveAnim = forgePersonnageMovementAnim(obj.id);
+  if (moveAnim) {
+    runSpriteAnimation(
+      targetEl,
+      resolveSpriteFrames(obj.id, { animation: moveAnim, fps: FORGE_PERSONNAGE_FPS, loop: true }),
+    );
+  }
+}
+
+// Déplace/anime UN personnage joueur pour ce tick — extrait du forEach de
+// forgeRunPersonnageControllerTick.
+function forgeRunPersonnagePlayerTick(screenData, obj) {
+  // Seul le personnage "joueur" (voir screens/rendering/personnage_role.py)
+  // est déplacé/animé au clavier — "ennemie"/"pnj" restent immobiles tant
+  // qu'aucune logique de flow ne les pilote (voir add_scene_object.py).
+  if (obj.kind !== 'personnage' || obj.personnage_role !== 'joueur' || !obj.personnage_commandes) return;
+  const cmd = obj.personnage_commandes;
+  const targetEl = document.querySelector(`[data-object-id="${obj.id}"]`);
+  if (!targetEl) return;
+
+  const { rawDx, rawDy } = forgeComputeMovementDelta(cmd);
+  const curLeft = Number.parseFloat(targetEl.style.left) || 0;
+  const curTop = Number.parseFloat(targetEl.style.top) || 0;
+  const boxWidth = Number.parseFloat(targetEl.style.width) || 0;
+  const boxHeight = Number.parseFloat(targetEl.style.height) || 0;
+  const box = {
+    left: curLeft, top: curTop, width: boxWidth, height: boxHeight,
+  };
+  const { dx, dy } = forgeResolveBlockedMovement(screenData, obj, targetEl, box, { rawDx, rawDy });
+
+  // Se tourne vers la direction TENTÉE même si le déplacement est
+  // finalement bloqué (fait face au mur/obstacle, plus naturel qu'un
+  // personnage qui reste dos tourné contre ce qui le bloque).
+  if (rawDx !== 0) applyObjectProperty(targetEl, 'orientation', rawDx < 0 ? 'gauche' : 'droite');
+  if (dx !== 0) applyObjectProperty(targetEl, 'pos_x_relatif', dx);
+  if (dy !== 0) applyObjectProperty(targetEl, 'pos_y_relatif', dy);
+  forgeApplyPersonnageAnimForTick(targetEl, obj, dx, dy);
+}
+
 // 50ms (20 fois/seconde) — même cadence que runScreenHeldKeyTriggers
 // (triggers.js), pour un déplacement perçu comme continu.
 function forgeRunPersonnageControllerTick(screenData) {
   forgeUpdateSceneCamera(screenData);
-  (screenData.elements || []).forEach((obj) => {
-    // Seul le personnage "joueur" (voir screens/rendering/personnage_role.py)
-    // est déplacé/animé au clavier — "ennemie"/"pnj" restent immobiles tant
-    // qu'aucune logique de flow ne les pilote (voir add_scene_object.py).
-    if (obj.kind !== 'personnage' || obj.personnage_role !== 'joueur' || !obj.personnage_commandes) return;
-    const cmd = obj.personnage_commandes;
-    const targetEl = document.querySelector(`[data-object-id="${obj.id}"]`);
-    if (!targetEl) return;
-
-    let rawDx = 0; let
-      rawDy = 0;
-    if (cmd.axe !== 'vertical') {
-      if (heldKeys.has(cmd.gauche)) rawDx -= cmd.vitesse;
-      if (heldKeys.has(cmd.droite)) rawDx += cmd.vitesse;
-    }
-    if (cmd.axe !== 'horizontal') {
-      if (heldKeys.has(cmd.haut)) rawDy -= cmd.vitesse;
-      if (heldKeys.has(cmd.bas)) rawDy += cmd.vitesse;
-    }
-
-    // Bloque le déplacement axe par axe (pas les deux à la fois dès qu'un
-    // seul est gêné) — glisser le long d'un mur en diagonale reste
-    // possible, plus naturel qu'un blocage total au moindre contact.
-    const curLeft = parseFloat(targetEl.style.left) || 0;
-    const curTop = parseFloat(targetEl.style.top) || 0;
-    const boxWidth = parseFloat(targetEl.style.width) || 0;
-    const boxHeight = parseFloat(targetEl.style.height) || 0;
-    let dx = rawDx; let
-      dy = rawDy;
-    if (dx !== 0) {
-      const candidateLeft = clampSceneObjectPosition(targetEl, 'left', curLeft + dx);
-      if (forgeWouldCollide(screenData, obj, candidateLeft, curTop, boxWidth, boxHeight)) dx = 0;
-    }
-    if (dy !== 0) {
-      const candidateTop = clampSceneObjectPosition(targetEl, 'top', curTop + dy);
-      if (forgeWouldCollide(screenData, obj, curLeft, candidateTop, boxWidth, boxHeight)) dy = 0;
-    }
-    // Se tourne vers la direction TENTÉE même si le déplacement est
-    // finalement bloqué (fait face au mur/obstacle, plus naturel qu'un
-    // personnage qui reste dos tourné contre ce qui le bloque).
-    if (rawDx !== 0) applyObjectProperty(targetEl, 'orientation', rawDx < 0 ? 'gauche' : 'droite');
-
-    // Même fps pour idle et walk (bug signalé par l'utilisateur : idle
-    // tournait à 4 i/s contre 8 pour walk, perçue comme "les autres
-    // animations sont lentes à côté de la marche" — aucune raison réelle
-    // de les désynchroniser).
-    if (dx === 0 && dy === 0) {
-      const idleAnim = forgePersonnageIdleAnim(obj.id);
-      if (idleAnim) {
-        runSpriteAnimation(
-          targetEl,
-          resolveSpriteFrames(obj.id, { animation: idleAnim, fps: FORGE_PERSONNAGE_FPS, loop: true }),
-        );
-      }
-      return;
-    }
-    if (dx !== 0) applyObjectProperty(targetEl, 'pos_x_relatif', dx);
-    if (dy !== 0) applyObjectProperty(targetEl, 'pos_y_relatif', dy);
-    const moveAnim = forgePersonnageMovementAnim(obj.id);
-    if (moveAnim) {
-      runSpriteAnimation(
-        targetEl,
-        resolveSpriteFrames(obj.id, { animation: moveAnim, fps: FORGE_PERSONNAGE_FPS, loop: true }),
-      );
-    }
-  });
+  (screenData.elements || []).forEach((obj) => forgeRunPersonnagePlayerTick(screenData, obj));
 }
 
 // Quelle pose jouer pour une touche d'ACTION (pas de déplacement) donnée —
@@ -261,7 +289,7 @@ function forgeStartPersonnageInteractListener(screenData) {
 // réinitialisé à chaque changement d'écran (voir showScreen()).
 function forgeStartPersonnageControllers(screenData) {
   forgeStopPersonnageControllers();
-  if (!screenData || screenData.kind !== 'jeu_2d') return;
+  if (screenData?.kind !== 'jeu_2d') return;
   const elements = screenData.elements || [];
   const hasPersonnage = elements.some((o) => o.kind === 'personnage' && o.personnage_role === 'joueur');
   const hasFond = elements.some((o) => o.kind === 'fond');
diff --git a/static/js/play/quiz-box-templates.js b/static/js/play/quiz-box-templates.js
index b5a83491..9b504279 100644
--- a/static/js/play/quiz-box-templates.js
+++ b/static/js/play/quiz-box-templates.js
@@ -15,27 +15,38 @@
 // `forgeDialogueBoxState` (déclarés dans dialogue-box-controller.js,
 // chargé à côté de ce fichier) sont des variables GLOBALES de script
 // classique (pas de module), lisibles ici telles quelles.
+// Extrait de forgeQuizProgressOnShow (lot 4 "modernisation JS", S7721) :
+// fonction pure (aucune fermeture), pas besoin d'être redéfinie à chaque appel.
+function isQuestionLine(line) { return line?.type === 'question'; }
+
+// Extrait de forgeQuizProgressOnShow (S3358) : segment "fait"/"courant"/
+// "à venir" de la barre d'étapes pour la question d'indice `i` (1-based).
+function forgeQuizProgressBarSegmentClass(i, current) {
+  if (i < current) return 'is-done';
+  if (i === current) return 'is-current';
+  return '';
+}
+
 // `progressSelector` : chaque modèle a son propre conteneur de barre
 // d'étapes (data-manga-role/data-classique-role, jamais data-quiz-role —
 // décoration propre à CHAQUE modèle, pas du contrat partagé).
 function forgeQuizProgressOnShow(widget, progressSelector) {
   if (!widget) return;
-  const quizObjectId = widget.getAttribute('data-object-id');
+  const quizObjectId = widget.dataset.objectId;
   const quizState = (typeof forgeQuizBoxState !== 'undefined') ? forgeQuizBoxState[quizObjectId] : null;
   if (!quizState) return;
   const dialogueState = (typeof forgeDialogueBoxState !== 'undefined') ? forgeDialogueBoxState[quizState.dialogueObjectId] : null;
   if (!dialogueState) return;
-  function isQuestion(line) { return line && line.type === 'question'; }
-  const total = dialogueState.lines.filter(isQuestion).length;
+  const total = dialogueState.lines.filter(isQuestionLine).length;
   if (total === 0) return;
-  const current = dialogueState.lines.slice(0, dialogueState.index + 1).filter(isQuestion).length;
+  const current = dialogueState.lines.slice(0, dialogueState.index + 1).filter(isQuestionLine).length;
   const header = widget.querySelector('[data-quiz-role="header"]');
   if (header) header.textContent = `Question ${current}/${total}`;
   const progressEl = widget.querySelector(progressSelector);
   if (progressEl) {
     const bars = [];
     for (let i = 1; i <= total; i++) {
-      bars.push(`<i class="${i < current ? 'is-done' : (i === current ? 'is-current' : '')}"></i>`);
+      bars.push(`<i class="${forgeQuizProgressBarSegmentClass(i, current)}"></i>`);
     }
     progressEl.innerHTML = bars.join('');
   }
@@ -79,15 +90,15 @@ function forgeQuizClassiqueOnQuizComplete(widget, result) {
   const content = widget.querySelector('.classiqueContent');
   const zone = widget.querySelector('[data-classique-role="result"]');
   if (!content || !zone) return;
-  const total = (result && result.totalCount) || 0;
-  const correct = (result && result.correctCount) || 0;
+  const total = result?.totalCount || 0;
+  const correct = result?.correctCount || 0;
   const pct = total > 0 ? Math.round((correct / total) * 100) : 0;
   const threshold = (typeof window !== 'undefined' && typeof window.FORGE_SUCCESS_THRESHOLD_PERCENT === 'number')
     ? window.FORGE_SUCCESS_THRESHOLD_PERCENT : 70;
   const passed = pct >= threshold;
   const titleEl = widget.querySelector('.classiqueHeaderTitle');
   const title = titleEl ? titleEl.textContent : 'Quiz';
-  const quizObjectId = widget.getAttribute('data-object-id');
+  const quizObjectId = widget.dataset.objectId;
   zone.innerHTML = `<div class="classiqueResultRing" style="--pct:${pct}"><span>${pct}%</span></div>`
     + `<p class="classiqueResultTitle">${correct} bonne${correct > 1 ? 's' : ''} réponse${correct > 1 ? 's' : ''} sur ${total}</p>`
     + `<p class="classiqueResultSub">« ${typeof forgeEscapeHtml === 'function' ? forgeEscapeHtml(title) : title} »</p>`
@@ -112,13 +123,13 @@ function forgeQuizMangaOnQuizComplete(widget, result) {
   if (!widget) return;
   const zone = widget.querySelector('[data-manga-role="result"]');
   if (!zone) return;
-  const total = (result && result.totalCount) || 0;
-  const correct = (result && result.correctCount) || 0;
+  const total = result?.totalCount || 0;
+  const correct = result?.correctCount || 0;
   const pct = total > 0 ? Math.round((correct / total) * 100) : 0;
   const threshold = (typeof window !== 'undefined' && typeof window.FORGE_SUCCESS_THRESHOLD_PERCENT === 'number')
     ? window.FORGE_SUCCESS_THRESHOLD_PERCENT : 70;
   const passed = pct >= threshold;
-  const quizObjectId = widget.getAttribute('data-object-id');
+  const quizObjectId = widget.dataset.objectId;
   zone.innerHTML = '<div class="mangaResultCard">'
     + '<span class="mangaResultTitle">Fin du quiz</span>'
     + `<p class="mangaResultScore">Score final : ${correct} / ${total}</p>`
diff --git a/static/js/play/screen-triggers-controller.js b/static/js/play/screen-triggers-controller.js
index a93fa696..b0a9f526 100644
--- a/static/js/play/screen-triggers-controller.js
+++ b/static/js/play/screen-triggers-controller.js
@@ -9,7 +9,7 @@
 function forgeRunScreenTriggers(screenData) {
   if (!screenData) return;
   const rules = screenData.screen_triggers;
-  if (!rules || !rules.length) return;
+  if (!rules?.length) return;
   rules.forEach((rule) => {
     if (rule.trigger !== 'affichage') return;
     forgeRunCollisionRuleAction(rule.action, null, {});
diff --git a/static/js/play/screens.js b/static/js/play/screens.js
index ca3cc997..1aa92fd6 100644
--- a/static/js/play/screens.js
+++ b/static/js/play/screens.js
@@ -82,7 +82,7 @@ function runScreenBackgroundMusic(screenId) {
     currentBackgroundAudio = null;
   }
   const screenData = screensData.find((s) => String(s.id) === String(screenId));
-  const url = screenData && screenData.background_music_url;
+  const url = screenData?.background_music_url;
   if (!url) return;
   currentBackgroundAudio = new Audio(url);
   currentBackgroundAudio.loop = true;
@@ -94,8 +94,8 @@ function runScreenBackgroundMusic(screenId) {
 // que soit la forme réelle de la fenêtre du joueur.
 function applyScreenAspect(aspect) {
   const parts = String(aspect).split('/');
-  const w = parseFloat(parts[0]) || 9; const
-    h = parseFloat(parts[1]) || 16;
+  const w = Number.parseFloat(parts[0]) || 9; const
+    h = Number.parseFloat(parts[1]) || 16;
   const frame = document.getElementById('playFrame');
   if (frame) {
     frame.style.setProperty('--ratio-w', w);
@@ -231,12 +231,12 @@ function collectAnimationClips(screenId) {
   function visit(sid) {
     if (visited[sid]) return;
     visited[sid] = true;
-    clips = clips.concat((gameData.animations || {})[String(sid)] || []);
+    clips = clips.concat(gameData.animations?.[String(sid)] || []);
     const screenData = screensData.find((s) => String(s.id) === String(sid));
     if (!screenData) return;
     screenData.elements.forEach((el) => {
       if (!el.element_type_id) return;
-      const templateScreenId = (gameData.element_types || {})[String(el.element_type_id)];
+      const templateScreenId = gameData.element_types?.[String(el.element_type_id)];
       if (templateScreenId != null) visit(templateScreenId);
     });
   }
diff --git a/static/js/play/triggers.js b/static/js/play/triggers.js
index f5eab654..9b595cd7 100644
--- a/static/js/play/triggers.js
+++ b/static/js/play/triggers.js
@@ -105,7 +105,7 @@ function bindHoverTexts() {
 // Espace déclenchent le même comportement que le clic.
 function bindClicks() {
   document.querySelectorAll('[data-element-id]').forEach((elDiv) => {
-    const elementId = parseInt(elDiv.dataset.elementId, 10);
+    const elementId = Number.parseInt(elDiv.dataset.elementId, 10);
     const triggers = findTriggerNodess(elementId, 'clic');
     if (triggers.length) {
       // Garde-fou anti-doublon : refreshRuntimeData() rappelle bindClicks()
@@ -133,8 +133,9 @@ function bindClicks() {
         // ligne cliquée" de savoir sur quel mail précis on a cliqué,
         // alors même que le déclencheur, lui, vise le Répéteur entier.
         const rowEl = ev.target.closest('.repeaterItem');
-        window.lastClickedRowId = rowEl ? parseInt(rowEl.dataset.rowId, 10) : null;
-        window.lastClickedDefinitionId = elDiv.dataset.definitionId ? parseInt(elDiv.dataset.definitionId, 10) : null;
+        window.lastClickedRowId = rowEl ? Number.parseInt(rowEl.dataset.rowId, 10) : null;
+        window.lastClickedDefinitionId = elDiv.dataset.definitionId
+          ? Number.parseInt(elDiv.dataset.definitionId, 10) : null;
         // Exécute CHAQUE déclencheur "Au clic" posé sur cet élément, pas
         // seulement le premier (voir le commentaire de findTriggerNodess).
         triggers.forEach((trigger) => runFlowFrom(trigger.node.id, trigger.screenId));
@@ -165,7 +166,7 @@ function bindClicks() {
 function bindHoverTriggers() {
   document.querySelectorAll('[data-element-id]').forEach((elDiv) => {
     if (elDiv.dataset.hoverTriggerBound) return;
-    const elementId = parseInt(elDiv.dataset.elementId, 10);
+    const elementId = Number.parseInt(elDiv.dataset.elementId, 10);
     const enterTriggers = findTriggerNodess(elementId, 'survol');
     const leaveTriggers = findTriggerNodess(elementId, 'fin_survol');
     if (!enterTriggers.length && !leaveTriggers.length) return;
diff --git a/static/js/scenes/collision-rules-editor.js b/static/js/scenes/collision-rules-editor.js
index bfbeb764..3644195a 100644
--- a/static/js/scenes/collision-rules-editor.js
+++ b/static/js/scenes/collision-rules-editor.js
@@ -39,7 +39,7 @@ const COLLISION_TRIGGER_LABELS = {
 // data_operations.py::DATA_OPERATIONS) — le champ valeur de l'étape
 // "Modifier une variable" (renderCollisionWizardVariableStep) se masque
 // pour celles-ci.
-const COLLISION_NO_VALUE_OPERATIONS = ['definir_bool_vrai', 'definir_bool_faux', 'basculer_bool'];
+const COLLISION_NO_VALUE_OPERATIONS = new Set(['definir_bool_vrai', 'definir_bool_faux', 'basculer_bool']);
 
 // obj.thumbnail_html (screens.render_scene_object) porte un style inline
 // PENSÉ POUR LE CANEVAS (position:absolute + left/top en dur, voir
@@ -242,7 +242,7 @@ function renderCollisionWizardAttendreStep(onChoose) {
 
 function collisionWizardAttendreNext() {
   const raw = document.getElementById('attendreWizSecondes').value;
-  const secondes = String(Math.max(0, parseFloat(raw) || 0));
+  const secondes = String(Math.max(0, Number.parseFloat(raw) || 0));
   const onChoose = _collisionWizard.onAttendreChosen;
   _collisionWizard.onAttendreChosen = null;
   onChoose(secondes);
@@ -265,7 +265,7 @@ function renderCollisionWizardObjectTargetStep(onChoose) {
       if (!objects.length) { grid.innerHTML = '<p class="hint">Aucun objet éligible sur ce jeu.</p>'; return; }
       grid.innerHTML = objects.map((o, i) => `<button type="button" class="collisionWizardChoice questTriggerObjectChoice" style="animation-delay:${i * 40}ms" onclick="collisionWizardObjectTargetChosen(${o.id})">`
           + `<div class="questTriggerObjectThumb">${collisionRuleThumbHtml(o)}</div>`
-          + `<span>${(o.name || '').replace(/</g, '&lt;')}</span>`
+          + `<span>${(o.name || '').replaceAll('<', '&lt;')}</span>`
         + '</button>').join('');
       _collisionWizard.onObjectTargetChosen = onChoose;
     });
@@ -314,7 +314,7 @@ function renderCollisionWizardAssetStep(onChoose, kind) {
     collisionWizardBodyEl().innerHTML = `<p class="hint mb-2">Aucun fichier ${label} dans "Mes assets" pour l'instant — importe-en un depuis le panneau de gauche (section "Mes assets"), puis recommence.</p>`;
     return;
   }
-  const options = assets.map((a) => `<option value="${a.url}">${(a.name || '').replace(/</g, '&lt;')}</option>`).join('');
+  const options = assets.map((a) => `<option value="${a.url}">${(a.name || '').replaceAll('<', '&lt;')}</option>`).join('');
   collisionWizardBodyEl().innerHTML = '<p class="hint mb-2">Quel fichier (voir "Mes assets") ?</p>'
     + `<select id="collisionWizardAssetSelect" style="width:100%; margin-bottom:10px;">${options}</select>`
     + '<button type="button" class="button primary" onclick="collisionWizardAssetNext()">Continuer</button>';
@@ -364,7 +364,7 @@ function collisionWizardIndicationNext() {
   const action = {
     type: 'indication', id: collisionGenerateActionId(), object_id: _collisionWizard.pendingIndicationObjectId, texte,
   };
-  if (dureeRaw) action.duree_ms = parseInt(dureeRaw, 10);
+  if (dureeRaw) action.duree_ms = Number.parseInt(dureeRaw, 10);
   _collisionWizard.pendingIndicationObjectId = null;
   const onChoose = _collisionWizard.onIndicationChosen;
   _collisionWizard.onIndicationChosen = null;
@@ -418,7 +418,7 @@ function renderCollisionWizardVariableStep(onChoose) {
 function collisionWizardVariableOperationChanged() {
   const operation = document.getElementById('varWizOperation').value;
   const valueInput = document.getElementById('varWizValue');
-  valueInput.style.display = COLLISION_NO_VALUE_OPERATIONS.indexOf(operation) === -1 ? '' : 'none';
+  valueInput.style.display = COLLISION_NO_VALUE_OPERATIONS.has(operation) ? 'none' : '';
 }
 
 function collisionWizardVariableNext() {
@@ -429,7 +429,7 @@ function collisionWizardVariableNext() {
     target_variable: document.getElementById('varWizVariable').value,
     data_operation: operation,
   };
-  if (COLLISION_NO_VALUE_OPERATIONS.indexOf(operation) === -1) {
+  if (!COLLISION_NO_VALUE_OPERATIONS.has(operation)) {
     action.data_value = document.getElementById('varWizValue').value;
   }
   const onChoose = _collisionWizard.onVariableChosen;
@@ -456,9 +456,10 @@ function collisionWizardVariableNext() {
 // dialogue, "attendre" disparaissait silencieusement.
 function renderCollisionWizardChainStep(leafAction, onDone, headAction) {
   headAction = headAction || leafAction;
+  const markCompletedChecked = leafAction.mark_completed ? ' checked' : '';
   const completionHtml = leafAction.type === 'dialogue'
     ? '<label style="display:flex; align-items:center; gap:6px; font-size:13px; margin-bottom:10px;">'
-        + `<input type="checkbox" id="condWizMarkCompleted"${leafAction.mark_completed ? ' checked' : ''}> Marquer ce dialogue comme terminé une fois joué`
+        + `<input type="checkbox" id="condWizMarkCompleted"${markCompletedChecked}> Marquer ce dialogue comme terminé une fois joué`
       + '</label>'
     : '';
   const choiceButtons = COLLISION_CHAIN_CHOICES.map((choice, i) => `<button type="button" class="collisionWizardChoice" style="animation-delay:${(i + 1) * 40}ms" onclick="collisionWizardChainDone('${choice}')"><span>${COLLISION_ACTION_LABELS[choice]}</span></button>`).join('');
diff --git a/static/js/scenes/global-variables.js b/static/js/scenes/global-variables.js
index 073ee3e0..7a4ac098 100644
--- a/static/js/scenes/global-variables.js
+++ b/static/js/scenes/global-variables.js
@@ -52,7 +52,7 @@ function createGlobalVariable(event) {
   fetch(`/game/${GAME_SLUG}/variables/new`, {
     method: 'POST', headers: { 'X-Requested-With': 'fetch' }, body,
   })
-    .then((r) => (r.ok ? r.json() : Promise.reject()))
+    .then((r) => (r.ok ? r.json() : Promise.reject(new Error(`HTTP ${r.status}`))))
     .then((json) => {
       if (!json.row_html) { window.location.reload(); return; }
       const tbody = document.getElementById('globalVariablesBody');
diff --git a/static/js/scenes/scene-editor.js b/static/js/scenes/scene-editor.js
index 7307b803..b1ca6560 100644
--- a/static/js/scenes/scene-editor.js
+++ b/static/js/scenes/scene-editor.js
@@ -38,7 +38,7 @@ function addSceneObject(kind, forgeCharacter, backgroundSlug, assetId, x, y) {
       // posé en base à ce stade (voir screens/scenes/add_scene_object.py),
       // seul un rechargement peut alors l'afficher.
       const contentType = r.headers.get('content-type') || '';
-      if (!r.ok || contentType.indexOf('application/json') === -1) {
+      if (!r.ok || !contentType.includes('application/json')) {
         window.location.reload();
         return null;
       }
@@ -124,7 +124,7 @@ function onCanvasDrop(ev) {
 // screens/scenes/add_scene_object.py) — absent pour un son/une vidéo,
 // qui n'ont rien à "poser".
 function uploadUserAsset(inputEl, sceneKind) {
-  const file = inputEl.files && inputEl.files[0];
+  const file = inputEl.files?.[0];
   if (!file) return;
   const body = new FormData();
   body.append('file', file);
@@ -193,14 +193,14 @@ function deleteSceneObject(id) {
   })
     .then((r) => {
       const contentType = r.headers.get('content-type') || '';
-      if (!r.ok || contentType.indexOf('application/json') === -1) {
+      if (!r.ok || !contentType.includes('application/json')) {
         window.location.reload();
         return null;
       }
       return r.json();
     })
     .then((json) => {
-      if (!json || !json.ok) return;
+      if (!json?.ok) return;
       const el = document.getElementById(`el-${id}`);
       if (el) el.remove();
       if (typeof _stopPersonnageIdlePreview === 'function') _stopPersonnageIdlePreview(id);
@@ -227,8 +227,8 @@ function deleteSceneObject(id) {
 function applyCameraSize() {
   const wEl = document.getElementById('scene-camera-w'); const
     hEl = document.getElementById('scene-camera-h');
-  const width = parseInt(wEl.value, 10) || 1; const
-    height = parseInt(hEl.value, 10) || 1;
+  const width = Number.parseInt(wEl.value, 10) || 1; const
+    height = Number.parseInt(hEl.value, 10) || 1;
   fetch(`/game/${GAME_SLUG}/screens/${SCREEN_ID}/scene-size`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
@@ -325,10 +325,10 @@ function onSceneObjectMouseDown(e, id) {
     startY = e.clientY;
   let lastClientX = e.clientX; let
     lastClientY = e.clientY;
-  let curLeft = parseFloat(el.style.left) || 0; let
-    curTop = parseFloat(el.style.top) || 0;
-  const width = parseFloat(el.style.width) || 0; const
-    height = parseFloat(el.style.height) || 0;
+  let curLeft = Number.parseFloat(el.style.left) || 0; let
+    curTop = Number.parseFloat(el.style.top) || 0;
+  const width = Number.parseFloat(el.style.width) || 0; const
+    height = Number.parseFloat(el.style.height) || 0;
   let moved = false;
   // Les panneaux flottants "🧩 Objets"/"⚙️ Propriétés" (voir static/style.css
   // .floatPanel, z-index:60) restent DÉLIBÉRÉMENT en position:fixed
@@ -405,10 +405,10 @@ function onSceneObjectResizeMouseDown(e, id) {
   const el = document.getElementById(`el-${id}`);
   let lastClientX = e.clientX; let
     lastClientY = e.clientY;
-  let curWidth = parseFloat(el.style.width) || 0; let
-    curHeight = parseFloat(el.style.height) || 0;
-  const left = parseFloat(el.style.left) || 0; const
-    top = parseFloat(el.style.top) || 0;
+  let curWidth = Number.parseFloat(el.style.width) || 0; let
+    curHeight = Number.parseFloat(el.style.height) || 0;
+  const left = Number.parseFloat(el.style.left) || 0; const
+    top = Number.parseFloat(el.style.top) || 0;
   // Voir la même note dans onSceneObjectMouseDown ci-dessus : au-dessus
   // des panneaux flottants le temps du geste, pour rester visible même
   // en redimensionnant sous l'un d'eux.
@@ -459,10 +459,10 @@ function initScenePosFields() {
   if (!xEl || !wEl || !CURRENT_SELECTED_ID) return;
   function apply() {
     const canvasEl = document.getElementById(`el-${CURRENT_SELECTED_ID}`);
-    const x = parseFloat(xEl.value) || 0; const
-      y = parseFloat(yEl.value) || 0;
-    const w = parseFloat(wEl.value) || 1; const
-      h = parseFloat(hEl.value) || 1;
+    const x = Number.parseFloat(xEl.value) || 0; const
+      y = Number.parseFloat(yEl.value) || 0;
+    const w = Number.parseFloat(wEl.value) || 1; const
+      h = Number.parseFloat(hEl.value) || 1;
     if (canvasEl) {
       canvasEl.style.left = `${x}px`; canvasEl.style.top = `${y}px`;
       canvasEl.style.width = `${w}px`; canvasEl.style.height = `${h}px`;
@@ -483,7 +483,7 @@ initScenePosFields();
 function swapSceneObjectCharacter(forgeCharacter) {
   const body = document.getElementById('personnagePanelBody');
   if (!body) return;
-  const objectId = parseInt(body.dataset.elementId, 10);
+  const objectId = Number.parseInt(body.dataset.elementId, 10);
   document.querySelectorAll('#personnageGallerySwap .iconGalleryTile').forEach((tile) => {
     tile.classList.toggle('selected', tile.getAttribute('onclick') === `swapSceneObjectCharacter('${forgeCharacter}')`);
   });
@@ -508,7 +508,7 @@ function swapSceneObjectCharacter(forgeCharacter) {
 function saveSceneObjectRole(role) {
   const body = document.getElementById('personnagePanelBody');
   if (!body) return;
-  const objectId = parseInt(body.dataset.elementId, 10);
+  const objectId = Number.parseInt(body.dataset.elementId, 10);
   fetch(`/game/${GAME_SLUG}/scene-objects/${objectId}/role`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
@@ -527,19 +527,19 @@ function saveSceneObjectRole(role) {
 function saveSceneObjectCollision() {
   const body = document.getElementById('collisionPanelBody');
   if (!body) return;
-  const objectId = parseInt(body.dataset.elementId, 10);
+  const objectId = Number.parseInt(body.dataset.elementId, 10);
   const enabled = document.getElementById('collision-enabled').checked;
   const shape = document.getElementById('collision-shape').value;
-  const width = parseFloat(document.getElementById('collision-width').value) || 0;
-  const height = parseFloat(document.getElementById('collision-height').value) || 0;
-  const offsetX = parseFloat(document.getElementById('collision-offset-x').value) || 0;
-  const offsetY = parseFloat(document.getElementById('collision-offset-y').value) || 0;
+  const width = Number.parseFloat(document.getElementById('collision-width').value) || 0;
+  const height = Number.parseFloat(document.getElementById('collision-height').value) || 0;
+  const offsetX = Number.parseFloat(document.getElementById('collision-offset-x').value) || 0;
+  const offsetY = Number.parseFloat(document.getElementById('collision-offset-y').value) || 0;
 
   const overlay = document.getElementById('collisionBoxOverlay');
   const objEl = document.getElementById(`el-${objectId}`);
   if (overlay && objEl) {
-    const objWidth = parseFloat(objEl.style.width) || 0; const
-      objHeight = parseFloat(objEl.style.height) || 0;
+    const objWidth = Number.parseFloat(objEl.style.width) || 0; const
+      objHeight = Number.parseFloat(objEl.style.height) || 0;
     overlay.style.width = `${width}px`;
     overlay.style.height = `${height}px`;
     overlay.style.left = `${(objWidth - width) / 2 + offsetX}px`;
@@ -579,14 +579,14 @@ function onCollisionBoxMouseDown(e, id) {
   e.preventDefault();
   const overlay = document.getElementById('collisionBoxOverlay');
   const objEl = document.getElementById(`el-${id}`);
-  const objWidth = parseFloat(objEl.style.width) || 0; const
-    objHeight = parseFloat(objEl.style.height) || 0;
+  const objWidth = Number.parseFloat(objEl.style.width) || 0; const
+    objHeight = Number.parseFloat(objEl.style.height) || 0;
   const startX = e.clientX; const
     startY = e.clientY;
-  const startLeft = parseFloat(overlay.style.left) || 0; const
-    startTop = parseFloat(overlay.style.top) || 0;
-  const boxWidth = parseFloat(overlay.style.width) || 0; const
-    boxHeight = parseFloat(overlay.style.height) || 0;
+  const startLeft = Number.parseFloat(overlay.style.left) || 0; const
+    startTop = Number.parseFloat(overlay.style.top) || 0;
+  const boxWidth = Number.parseFloat(overlay.style.width) || 0; const
+    boxHeight = Number.parseFloat(overlay.style.height) || 0;
 
   function onMove(ev) {
     overlay.style.left = `${startLeft + (ev.clientX - startX)}px`;
@@ -595,8 +595,8 @@ function onCollisionBoxMouseDown(e, id) {
   function onUp() {
     document.removeEventListener('mousemove', onMove);
     document.removeEventListener('mouseup', onUp);
-    const offsetX = (parseFloat(overlay.style.left) || 0) - (objWidth - boxWidth) / 2;
-    const offsetY = (parseFloat(overlay.style.top) || 0) - (objHeight - boxHeight) / 2;
+    const offsetX = (Number.parseFloat(overlay.style.left) || 0) - (objWidth - boxWidth) / 2;
+    const offsetY = (Number.parseFloat(overlay.style.top) || 0) - (objHeight - boxHeight) / 2;
     updateCollisionFields(boxWidth, boxHeight, offsetX, offsetY);
     saveSceneObjectCollision();
   }
@@ -614,14 +614,14 @@ function onCollisionBoxResizeMouseDown(e, id) {
   e.preventDefault();
   const overlay = document.getElementById('collisionBoxOverlay');
   const objEl = document.getElementById(`el-${id}`);
-  const objWidth = parseFloat(objEl.style.width) || 0; const
-    objHeight = parseFloat(objEl.style.height) || 0;
+  const objWidth = Number.parseFloat(objEl.style.width) || 0; const
+    objHeight = Number.parseFloat(objEl.style.height) || 0;
   const startX = e.clientX; const
     startY = e.clientY;
-  const startWidth = parseFloat(overlay.style.width) || 0; const
-    startHeight = parseFloat(overlay.style.height) || 0;
-  const left = parseFloat(overlay.style.left) || 0; const
-    top = parseFloat(overlay.style.top) || 0;
+  const startWidth = Number.parseFloat(overlay.style.width) || 0; const
+    startHeight = Number.parseFloat(overlay.style.height) || 0;
+  const left = Number.parseFloat(overlay.style.left) || 0; const
+    top = Number.parseFloat(overlay.style.top) || 0;
 
   function onMove(ev) {
     overlay.style.width = `${Math.max(4, startWidth + (ev.clientX - startX))}px`;
@@ -630,8 +630,8 @@ function onCollisionBoxResizeMouseDown(e, id) {
   function onUp() {
     document.removeEventListener('mousemove', onMove);
     document.removeEventListener('mouseup', onUp);
-    const newWidth = parseFloat(overlay.style.width); const
-      newHeight = parseFloat(overlay.style.height);
+    const newWidth = Number.parseFloat(overlay.style.width); const
+      newHeight = Number.parseFloat(overlay.style.height);
     const offsetX = left - (objWidth - newWidth) / 2;
     const offsetY = top - (objHeight - newHeight) / 2;
     updateCollisionFields(newWidth, newHeight, offsetX, offsetY);
@@ -650,12 +650,12 @@ function onCollisionBoxResizeMouseDown(e, id) {
 function saveSceneObjectCommands() {
   const body = document.getElementById('personnageCommandsBody');
   if (!body) return;
-  const objectId = parseInt(body.dataset.elementId, 10);
+  const objectId = Number.parseInt(body.dataset.elementId, 10);
   const extra = [];
   document.querySelectorAll('#personnageCommandsExtra .personnageCommandExtraRow').forEach((row) => {
     const toucheEl = row.querySelector('.personnageKeyCapture');
     const animEl = row.querySelector('.cmdExtraAnim');
-    if (toucheEl && toucheEl.value && animEl && animEl.value) {
+    if (toucheEl?.value && animEl?.value) {
       extra.push({ touche: toucheEl.value, animation: animEl.value });
     }
   });
@@ -713,7 +713,7 @@ function personnageCommandExtraRowEl(objectId, touche, animation) {
   row.className = 'field is-grouped personnageCommandExtraRow';
   const animNames = Object.keys(ELEMENT_ANIMATIONS_MAP[objectId] || {});
   const options = animNames.map((name) => `<option value="${name}"${name === animation ? ' selected' : ''}>${name}</option>`).join('');
-  row.innerHTML = `<div class="control"><input class="input is-small personnageKeyCapture" readonly placeholder="Touche..." value="${(touche || '').replace(/"/g, '&quot;')}"></div>`
+  row.innerHTML = `<div class="control"><input class="input is-small personnageKeyCapture" readonly placeholder="Touche..." value="${(touche || '').replaceAll('"', '&quot;')}"></div>`
     + `<div class="control"><div class="select is-small"><select class="cmdExtraAnim">${options}</select></div></div>`
     + '<div class="control"><button type="button" class="button is-small" onclick="this.closest(\'.personnageCommandExtraRow\').remove(); saveSceneObjectCommands();">×</button></div>';
   const keyInput = row.querySelector('.personnageKeyCapture');
@@ -727,7 +727,7 @@ function addPersonnageCommandExtraRow() {
   const body = document.getElementById('personnageCommandsBody');
   const container = document.getElementById('personnageCommandsExtra');
   if (!body || !container) return;
-  const objectId = parseInt(body.dataset.elementId, 10);
+  const objectId = Number.parseInt(body.dataset.elementId, 10);
   container.appendChild(personnageCommandExtraRowEl(objectId, '', ''));
 }
 
@@ -767,7 +767,7 @@ function refreshSceneObjectNames() {
 function forgeHexToRgb(hex) {
   hex = String(hex || '').replace('#', '');
   if (hex.length === 3) hex = hex.split('').map((c) => c + c).join('');
-  const num = parseInt(hex, 16);
+  const num = Number.parseInt(hex, 16);
   if (Number.isNaN(num) || hex.length !== 6) return [0, 0, 0];
   return [(num >> 16) & 255, (num >> 8) & 255, num & 255];
 }
@@ -820,7 +820,7 @@ function saveDialogueBoxStyle(objectId) {
   };
   checkDialogueBoxContrast(style);
   const el = document.getElementById(`el-${objectId}`);
-  const widget = el && el.querySelector('.dialogueBoxWidget');
+  const widget = el?.querySelector('.dialogueBoxWidget');
   if (widget) {
     widget.style.fontFamily = style.font_family;
     widget.style.fontSize = `${style.font_size}px`;
@@ -847,10 +847,10 @@ function saveDialogueBoxStyle(objectId) {
 function _selectQuizBoxTemplate(objectId, key, gridId) {
   const grid = document.getElementById(gridId);
   if (grid) {
-    grid.setAttribute('data-selected-template', key);
+    grid.dataset.selectedTemplate = key;
     const tiles = grid.querySelectorAll('.quizTemplateTile');
-    for (let i = 0; i < tiles.length; i++) {
-      tiles[i].classList.toggle('is-selected', tiles[i].getAttribute('data-template') === key);
+    for (const tile of tiles) {
+      tile.classList.toggle('is-selected', tile.dataset.template === key);
     }
   }
   saveQuizBoxConfig(objectId);
@@ -887,10 +887,10 @@ function saveQuizBoxConfig(objectId) {
     const grid = document.getElementById(gridId);
     if (!grid) return meta ? meta.getAttribute(metaAttr) : null;
     const selectedTile = grid.querySelector('.quizTemplateTile.is-selected');
-    return grid.getAttribute('data-selected-template') || (selectedTile && selectedTile.getAttribute('data-template'));
+    return grid.dataset.selectedTemplate || selectedTile?.dataset.template;
   }
   const fullscreenEl = document.getElementById('quiz-fullscreen');
-  const fullscreenChanged = fullscreenEl.checked !== (fullscreenEl.getAttribute('data-was-checked') === '1');
+  const fullscreenChanged = fullscreenEl.checked !== (fullscreenEl.dataset.wasChecked === '1');
   const config = {
     fullscreen: fullscreenEl.checked,
     timer_mode: document.getElementById('quiz-timer-mode').value,
@@ -907,7 +907,7 @@ function saveQuizBoxConfig(objectId) {
     .then((data) => {
       if (fullscreenChanged) { window.location.reload(); return; }
       const el = document.getElementById(`el-${objectId}`);
-      const widget = el && el.querySelector('.quizBoxWidget');
+      const widget = el?.querySelector('.quizBoxWidget');
       if (widget && data.rendered_html) widget.outerHTML = data.rendered_html;
     });
 }
@@ -915,7 +915,7 @@ function saveQuizBoxConfig(objectId) {
 function initPersonnageCommandsPanel() {
   const body = document.getElementById('personnageCommandsBody');
   if (!body) return;
-  const objectId = parseInt(body.dataset.elementId, 10);
+  const objectId = Number.parseInt(body.dataset.elementId, 10);
   ['cmd-haut', 'cmd-bas', 'cmd-gauche', 'cmd-droite', 'cmd-interagir'].forEach((id) => {
     bindPersonnageKeyCapture(document.getElementById(id));
   });
diff --git a/static/js/screen_edit/panel-init.js b/static/js/screen_edit/panel-init.js
index ea0b0c43..12a5eaf7 100644
--- a/static/js/screen_edit/panel-init.js
+++ b/static/js/screen_edit/panel-init.js
@@ -11,10 +11,10 @@ function initBuilderPanel() {
     if (!xEl || !wEl) return;
     function apply() {
       const canvasEl = document.getElementById(`el-${CURRENT_SELECTED_ID}`);
-      const x = parseFloat(xEl.value) || 0; const
-        y = parseFloat(yEl.value) || 0;
-      const w = parseFloat(wEl.value) || 1; const
-        h = parseFloat(hEl.value) || 1;
+      const x = Number.parseFloat(xEl.value) || 0; const
+        y = Number.parseFloat(yEl.value) || 0;
+      const w = Number.parseFloat(wEl.value) || 1; const
+        h = Number.parseFloat(hEl.value) || 1;
       if (canvasEl) {
         canvasEl.style.left = `${x}%`; canvasEl.style.top = `${y}%`;
         canvasEl.style.width = `${w}%`; canvasEl.style.height = `${h}%`;
@@ -109,7 +109,7 @@ function bindJaugeDefinitionSelect() {
   const champNomSel = document.getElementById('field-champ_nom');
   if (!defSel || !rowSel || !champSel || !champNomSel) return; // pas la Jauge
   defSel.addEventListener('change', () => {
-    const info = (DEFINITIONS_DATA || {})[defSel.value] || { rows: [], fields: [] };
+    const info = DEFINITIONS_DATA?.[defSel.value] || { rows: [], fields: [] };
     rowSel.innerHTML = info.rows.length
       ? info.rows.map((r) => `<option value="${r.id}">${r.label}</option>`).join('')
       : '<option value="">Aucune donnée dans cet objet</option>';
@@ -149,9 +149,9 @@ function bindDefinitionFieldSelects(defSelId, fieldSelIds) {
   const fieldSels = fieldSelIds.map((id) => document.getElementById(id)).filter(Boolean);
   if (!fieldSels.length) return;
   defSel.addEventListener('change', () => {
-    const info = (DEFINITIONS_DATA || {})[defSel.value] || { fields: [] };
-    const opts = `<option value="">(sélectionner un objet d'abord)</option>${
-      info.fields.map((f) => `<option value="${f.name}">${fieldOptionLabel(f)}</option>`).join('')}`;
+    const info = DEFINITIONS_DATA?.[defSel.value] || { fields: [] };
+    const fieldOptionsHtml = info.fields.map((f) => `<option value="${f.name}">${fieldOptionLabel(f)}</option>`).join('');
+    const opts = `<option value="">(sélectionner un objet d'abord)</option>${fieldOptionsHtml}`;
     fieldSels.forEach((sel) => { sel.innerHTML = opts; });
   });
 }
@@ -200,7 +200,7 @@ function addClauseRow(key) {
   // bloquée sur "(sélectionner un objet d'abord)" même si un objet est
   // déjà réglé plus haut dans le panneau).
   const defSel = document.getElementById('field-data_definition_id');
-  if (defSel && defSel.value) defSel.dispatchEvent(new Event('change'));
+  if (defSel?.value) defSel.dispatchEvent(new Event('change'));
   // Initialise le sélecteur de valeur (fixe/dynamique/variable) de cette
   // nouvelle ligne — sans effet sur les lignes déjà initialisées.
   initFilterValuePickers();
@@ -227,9 +227,9 @@ function bindClauseListDefinitionSelect(defSelId) {
   const defSel = document.getElementById(defSelId);
   if (!defSel) return;
   defSel.addEventListener('change', () => {
-    const info = (DEFINITIONS_DATA || {})[defSel.value] || { fields: [] };
-    const opts = `<option value="">(sélectionner un objet d'abord)</option>${
-      info.fields.map((f) => `<option value="${f.name}">${fieldOptionLabel(f)}</option>`).join('')}`;
+    const info = DEFINITIONS_DATA?.[defSel.value] || { fields: [] };
+    const fieldOptionsHtml = info.fields.map((f) => `<option value="${f.name}">${fieldOptionLabel(f)}</option>`).join('');
+    const opts = `<option value="">(sélectionner un objet d'abord)</option>${fieldOptionsHtml}`;
     document.querySelectorAll('.clauseChampSelect').forEach((sel) => {
       const current = sel.value;
       sel.innerHTML = opts;
@@ -266,8 +266,9 @@ function _filterValueDefinitionId(objName) {
 }
 
 function populateFilterValueFields(fieldSel, defId, selectedName) {
-  const info = (DEFINITIONS_DATA || {})[defId] || { fields: [] };
-  fieldSel.innerHTML = `<option value="">— champ —</option>${info.fields.map((f) => `<option value="${f.name}"${f.name === selectedName ? ' selected' : ''}>${fieldOptionLabel(f)}</option>`).join('')}`;
+  const info = DEFINITIONS_DATA?.[defId] || { fields: [] };
+  const fieldOptionsHtml = info.fields.map((f) => `<option value="${f.name}"${f.name === selectedName ? ' selected' : ''}>${fieldOptionLabel(f)}</option>`).join('');
+  fieldSel.innerHTML = `<option value="">— champ —</option>${fieldOptionsHtml}`;
 }
 
 function updateFilterValueFromDynamic(wrap) {
diff --git a/static/js/screen_edit/personnage-panel.js b/static/js/screen_edit/personnage-panel.js
index a1310b0b..76221a48 100644
--- a/static/js/screen_edit/personnage-panel.js
+++ b/static/js/screen_edit/personnage-panel.js
@@ -9,7 +9,7 @@
 
 function _personnageElementId() {
   const body = document.getElementById('personnagePanelBody');
-  return body ? parseInt(body.dataset.elementId, 10) : null;
+  return body ? Number.parseInt(body.dataset.elementId, 10) : null;
 }
 
 function _savePersonnageData(data) {
diff --git a/static/js/screen_edit/personnage-preview.js b/static/js/screen_edit/personnage-preview.js
index cd65d1f3..f76e9e0b 100644
--- a/static/js/screen_edit/personnage-preview.js
+++ b/static/js/screen_edit/personnage-preview.js
@@ -16,7 +16,7 @@ function _stopPersonnageIdlePreview(elementId) {
 
 function _startPersonnageIdlePreview(targetEl, elementId, frames, fps) {
   _stopPersonnageIdlePreview(elementId);
-  if (!frames || !frames.length) return;
+  if (!frames?.length) return;
   targetEl.src = frames[0];
   if (frames.length === 1) return;
   let frameIndex = 0;
@@ -42,7 +42,7 @@ function restartPersonnageIdlePreview(elementId, animations) {
 
 function startAllPersonnagePreviews() {
   document.querySelectorAll('#canvas [data-personnage="1"]').forEach((targetEl) => {
-    const elementId = parseInt(targetEl.dataset.elementId, 10);
+    const elementId = Number.parseInt(targetEl.dataset.elementId, 10);
     const animations = ELEMENT_ANIMATIONS_MAP[elementId];
     const frames = (animations && (animations.idle || Object.values(animations)[0])) || null;
     // Pas d'entrée dans ELEMENT_ANIMATIONS_MAP (personnage vidé/sprite
diff --git a/static/js/screen_edit/tree-panels.js b/static/js/screen_edit/tree-panels.js
index 5d22770b..88603a11 100644
--- a/static/js/screen_edit/tree-panels.js
+++ b/static/js/screen_edit/tree-panels.js
@@ -123,7 +123,7 @@ if (!window.__forgeFloatPanelDragBound) {
     function onUp() {
       document.removeEventListener('mousemove', onMove);
       document.removeEventListener('mouseup', onUp);
-      saveFloatPanelState(key, { left: parseFloat(panel.style.left), top: parseFloat(panel.style.top) });
+      saveFloatPanelState(key, { left: Number.parseFloat(panel.style.left), top: Number.parseFloat(panel.style.top) });
     }
     document.addEventListener('mousemove', onMove);
     document.addEventListener('mouseup', onUp);
@@ -144,7 +144,7 @@ function addIconElement(iconClass) {
   form.method = 'post';
   form.action = ELEMENT_ADD_URL;
   form.innerHTML = '<input type="hidden" name="widget" value="icone">'
-    + `<input type="hidden" name="icon_class" value="${iconClass.replace(/"/g, '&quot;')}">`;
+    + `<input type="hidden" name="icon_class" value="${iconClass.replaceAll('"', '&quot;')}">`;
   document.body.appendChild(form);
   form.requestSubmit();
 }
@@ -314,7 +314,10 @@ if (!window.__forgeTreeDragBound) {
     e.preventDefault();
     e.dataTransfer.dropEffect = 'move';
     clearTreeDropIndicators();
-    row.classList.add(zone === 'before' ? 'dropBefore' : zone === 'after' ? 'dropAfter' : 'dropInside');
+    let zoneClass = 'dropInside';
+    if (zone === 'before') zoneClass = 'dropBefore';
+    else if (zone === 'after') zoneClass = 'dropAfter';
+    row.classList.add(zoneClass);
   });
 
   document.addEventListener('drop', (e) => {
@@ -456,10 +459,10 @@ function onElementMouseDown(e, id) {
   const rect = canvas.getBoundingClientRect();
   const startX = e.clientX; const
     startY = e.clientY;
-  const startLeft = parseFloat(el.style.left); const
-    startTop = parseFloat(el.style.top);
-  const width = parseFloat(el.style.width); const
-    height = parseFloat(el.style.height);
+  const startLeft = Number.parseFloat(el.style.left); const
+    startTop = Number.parseFloat(el.style.top);
+  const width = Number.parseFloat(el.style.width); const
+    height = Number.parseFloat(el.style.height);
   let moved = false;
   // Un clic (sans glisser) sélectionne l'élément précis qu'on a touché —
   // même s'il est physiquement imbriqué dans ce conteneur — pour éviter de
@@ -481,8 +484,8 @@ function onElementMouseDown(e, id) {
     document.removeEventListener('mousemove', onMove);
     document.removeEventListener('mouseup', onUp);
     if (moved) {
-      const newLeft = parseFloat(el.style.left); const
-        newTop = parseFloat(el.style.top);
+      const newLeft = Number.parseFloat(el.style.left); const
+        newTop = Number.parseFloat(el.style.top);
       updatePosFields(newLeft, newTop, width, height);
       saveGeometry(id, newLeft, newTop, width, height);
     } else if (String(clickedId) !== String(CURRENT_SELECTED_ID)) {
@@ -501,10 +504,10 @@ function onResizeMouseDown(e, id) {
   const rect = canvas.getBoundingClientRect();
   const startX = e.clientX; const
     startY = e.clientY;
-  const startWidth = parseFloat(el.style.width); const
-    startHeight = parseFloat(el.style.height);
-  const left = parseFloat(el.style.left); const
-    top = parseFloat(el.style.top);
+  const startWidth = Number.parseFloat(el.style.width); const
+    startHeight = Number.parseFloat(el.style.height);
+  const left = Number.parseFloat(el.style.left); const
+    top = Number.parseFloat(el.style.top);
 
   function onMove(ev) {
     const dx = ev.clientX - startX; const
@@ -517,8 +520,8 @@ function onResizeMouseDown(e, id) {
   function onUp() {
     document.removeEventListener('mousemove', onMove);
     document.removeEventListener('mouseup', onUp);
-    const newWidth = parseFloat(el.style.width); const
-      newHeight = parseFloat(el.style.height);
+    const newWidth = Number.parseFloat(el.style.width); const
+      newHeight = Number.parseFloat(el.style.height);
     updatePosFields(left, top, newWidth, newHeight);
     saveGeometry(id, left, top, newWidth, newHeight);
   }
diff --git a/static/js/triggers/trigger-editor.js b/static/js/triggers/trigger-editor.js
index 036d878f..de30d9c1 100644
--- a/static/js/triggers/trigger-editor.js
+++ b/static/js/triggers/trigger-editor.js
@@ -43,12 +43,12 @@ function triggerBubbleKind(speaker) {
 // valeur déjà enregistrée.
 function triggerSpeakerOptions(currentSpeaker) {
   const options = ['Joueur'].concat(SCENE_OBJECT_NAMES);
-  if (currentSpeaker && options.indexOf(currentSpeaker) === -1) options.push(currentSpeaker);
+  if (currentSpeaker && !options.includes(currentSpeaker)) options.push(currentSpeaker);
   return options;
 }
 
 function triggerEscAttr(str) {
-  return (str || '').replace(/"/g, '&quot;');
+  return (str || '').replaceAll('"', '&quot;');
 }
 
 // ---------- Colonne = un graphe de logique lu par déclencheur ----------
@@ -82,11 +82,17 @@ function triggerAudioAssetOptions() {
   return (typeof USER_ASSETS_OPTIONS !== 'undefined' ? USER_ASSETS_OPTIONS : []).filter((a) => a.kind === 'audio');
 }
 
+function triggerAudioOptionHtml(asset, audioUrl) {
+  const selected = asset.url === audioUrl ? ' selected' : '';
+  return `<option value="${asset.url.replaceAll('"', '&quot;')}"${selected}>${asset.name.replaceAll('<', '&lt;')}</option>`;
+}
+
 function triggerBubbleAudioControlHtml(dialogueId, index, audioUrl) {
   const assetOptions = triggerAudioAssetOptions();
-  const selectOptions = `<option value="">Aucune voix off</option>${assetOptions.map((a) => `<option value="${a.url.replace(/"/g, '&quot;')}"${a.url === audioUrl ? ' selected' : ''}>${a.name.replace(/</g, '&lt;')}</option>`).join('')}`;
+  const optionsHtml = assetOptions.map((a) => triggerAudioOptionHtml(a, audioUrl)).join('');
+  const selectOptions = `<option value="">Aucune voix off</option>${optionsHtml}`;
   const preview = audioUrl
-    ? `<audio controls preload="none" src="${audioUrl.replace(/"/g, '&quot;')}" class="questBubbleAudioPreview"></audio>`
+    ? `<audio controls preload="none" src="${audioUrl.replaceAll('"', '&quot;')}" class="questBubbleAudioPreview"></audio>`
     : '';
   return (
     '<div class="questBubbleAudioRow">'
@@ -101,7 +107,7 @@ function triggerBubbleAudioControlHtml(dialogueId, index, audioUrl) {
 // optionnelle) — trois zones distinctes, pas un seul bloc.
 function triggerDialogueBubbleHtml(dialogueId, line, index) {
   const kind = triggerBubbleKind(line.speaker);
-  const speakerSelect = triggerSpeakerOptions(line.speaker).map((name) => `<option value="${name.replace(/"/g, '&quot;')}"${name === line.speaker ? ' selected' : ''}>${name === 'Joueur' ? 'Joueur' : name}</option>`).join('');
+  const speakerSelect = triggerSpeakerOptions(line.speaker).map((name) => `<option value="${name.replaceAll('"', '&quot;')}"${name === line.speaker ? ' selected' : ''}>${name === 'Joueur' ? 'Joueur' : name}</option>`).join('');
   return (
     '<div class="questBubbleRow">'
       + `<div class="questBubble questBubble-${kind}">`
@@ -112,7 +118,7 @@ function triggerDialogueBubbleHtml(dialogueId, line, index) {
         + '<div class="questBubbleBody">'
           + '<textarea class="questBubbleText" rows="1" placeholder="Réplique..." '
             + 'oninput="this.style.height=\'auto\'; this.style.height=this.scrollHeight+\'px\';" '
-            + `onchange="triggerInlineUpdateBubbleText('${dialogueId}', ${index}, this.value)">${line.text.replace(/</g, '&lt;')}</textarea>${
+            + `onchange="triggerInlineUpdateBubbleText('${dialogueId}', ${index}, this.value)">${line.text.replaceAll('<', '&lt;')}</textarea>${
               triggerBubbleAudioControlHtml(dialogueId, index, line.audio_url)
             }</div>`
       + '</div>'
@@ -168,7 +174,7 @@ function triggerQuestionBubbleHtml(dialogueId, line, index) {
 function triggerVariableActionLabel(item) {
   const opLabel = (typeof DATA_OPERATION_LABELS_MAP !== 'undefined' && DATA_OPERATION_LABELS_MAP[item.data_operation]) || item.data_operation;
   const valuePart = (item.data_value !== undefined && item.data_value !== null && item.data_value !== '') ? ` ${item.data_value}` : '';
-  return `${(item.target_variable || '').replace(/</g, '&lt;')} — ${opLabel.replace(/</g, '&lt;')}${valuePart}`;
+  return `${(item.target_variable || '').replaceAll('<', '&lt;')} — ${opLabel.replaceAll('<', '&lt;')}${valuePart}`;
 }
 
 // Feuille "Modifier une variable" — un encart compact (même largeur que
@@ -201,7 +207,7 @@ const COLLISION_LEAF_PILL_LABELS = {
 };
 
 function triggerItemLeafId(item) {
-  return item.type === 'dialogue' ? (item.dialogue && item.dialogue.id) : item.id;
+  return item.type === 'dialogue' ? item.dialogue?.id : item.id;
 }
 
 // URL commune retrait/déplacement — objet (routes/triggers/triggers.py)
@@ -264,7 +270,7 @@ function triggerLeafPillHtml(item, target, targetId, index, total) {
 }
 
 function triggerAssetFilename(url) {
-  return ((url || '').split('/').pop() || url || '').replace(/</g, '&lt;');
+  return ((url || '').split('/').pop() || url || '').replaceAll('<', '&lt;');
 }
 
 function triggerGenericLeafBoxHtml(title, text) {
@@ -295,7 +301,7 @@ function triggerLeafBoxHtml(item) {
     return triggerGenericLeafBoxHtml('Vidéo', `${triggerAssetFilename(item.asset_url)} — ${mLabel}`);
   }
   if (item.type === 'indication') {
-    return triggerGenericLeafBoxHtml('Indication', `Objet #${item.object_id} — ${(item.texte || '').replace(/</g, '&lt;')}`);
+    return triggerGenericLeafBoxHtml('Indication', `Objet #${item.object_id} — ${(item.texte || '').replaceAll('<', '&lt;')}`);
   }
   if (item.type === 'attendre') {
     return triggerGenericLeafBoxHtml('Attendre', `${item.data_value || '0'} seconde(s)`);
@@ -328,7 +334,7 @@ function triggerAppendButtonHtml(target, targetId, afterId) {
 }
 
 function triggerActionChainHtml(chain, target, targetId) {
-  if (!chain || !chain.length) return '';
+  if (!chain?.length) return '';
   return chain.map((item, i) => {
     const leafId = triggerItemLeafId(item);
     return (
@@ -383,14 +389,14 @@ const _triggerCollapsed = {};
 let _triggerActiveDialogueId = null;
 
 function _chainLeafIds(chain) {
-  return (chain || []).map((item) => (item.type === 'dialogue' ? (item.dialogue && item.dialogue.id) : item.id)).filter(Boolean);
+  return (chain || []).map((item) => (item.type === 'dialogue' ? item.dialogue?.id : item.id)).filter(Boolean);
 }
 
 function _triggerLeafIds(trigger) {
   if (trigger.condition) {
     const vrai = trigger.condition.si_vrai; const
       faux = trigger.condition.si_faux;
-    return _chainLeafIds(vrai && vrai.chain).concat(_chainLeafIds(faux && faux.chain));
+    return _chainLeafIds(vrai?.chain).concat(_chainLeafIds(faux?.chain));
   }
   return _chainLeafIds(trigger.chain);
 }
@@ -398,10 +404,11 @@ function _triggerLeafIds(trigger) {
 function triggerChainHtml(trigger) {
   const isCollapsed = !!_triggerCollapsed[trigger.object_id];
   const leafIds = _triggerLeafIds(trigger);
-  const isActive = _triggerActiveDialogueId && leafIds.indexOf(_triggerActiveDialogueId) !== -1;
-  const cardOnclick = `triggerClickObjectCard(${trigger.object_id}, ${leafIds[0] ? `'${leafIds[0]}'` : 'null'})`;
+  const isActive = _triggerActiveDialogueId && leafIds.includes(_triggerActiveDialogueId);
+  const firstLeafArg = leafIds[0] ? `'${leafIds[0]}'` : 'null';
+  const cardOnclick = `triggerClickObjectCard(${trigger.object_id}, ${firstLeafArg})`;
   const card = `<div class="questTriggerObjectCard" title="Cliquer pour replier/déplier — replie aussi la logique associée" onclick="${cardOnclick}">${collisionRuleThumbHtml(trigger)
-  }<span class="questTriggerObjectName">${(trigger.object_name || '').replace(/</g, '&lt;')}</span>`
+  }<span class="questTriggerObjectName">${(trigger.object_name || '').replaceAll('<', '&lt;')}</span>`
       + '<span class="questTriggerCollapseChevron">▾</span>'
     + '</div>';
   if (isCollapsed) {
@@ -465,7 +472,7 @@ function triggerCondArrowHtml(kind, label) {
 
 function triggerConditionColumnHtml(condition, target, targetId) {
   const opLabel = CONDITION_OPERATOR_LABELS_MAP[condition.operateur] || condition.operateur;
-  const label = `${(condition.variable || '').replace(/</g, '&lt;')} ${(opLabel || '').replace(/</g, '&lt;')} ${(condition.valeur || '').replace(/</g, '&lt;')}`;
+  const label = `${(condition.variable || '').replaceAll('<', '&lt;')} ${(opLabel || '').replaceAll('<', '&lt;')} ${(condition.valeur || '').replaceAll('<', '&lt;')}`;
   const branchesHtml = ['si_vrai', 'si_faux'].map((branchKey) => {
     const kind = branchKey === 'si_vrai' ? 'yes' : 'no';
     const arrowLabel = branchKey === 'si_vrai' ? '✓ Vrai' : '✕ Faux';
@@ -520,7 +527,7 @@ function _registerChainDialogues(chain, owner, dialogueIds) {
 // l'autre.
 function _clearRegistryEntriesWithKey(key) {
   Object.keys(_triggerDialogueRegistry).forEach((id) => {
-    if (Object.prototype.hasOwnProperty.call(_triggerDialogueRegistry[id], key)) delete _triggerDialogueRegistry[id];
+    if (Object.hasOwn(_triggerDialogueRegistry[id], key)) delete _triggerDialogueRegistry[id];
   });
 }
 
@@ -550,8 +557,8 @@ function triggerLoadAll() {
       // sauf s'il y en a déjà un actif encore présent, auquel cas on le
       // garde (cliquer sur une autre carte reste possible, voir
       // triggerClickObjectCard).
-      if (dialogueIds.indexOf(_triggerActiveDialogueId) === -1) {
-        _triggerActiveDialogueId = dialogueIds[dialogueIds.length - 1] || null;
+      if (!dialogueIds.includes(_triggerActiveDialogueId)) {
+        _triggerActiveDialogueId = dialogueIds.at(-1) || null;
       }
       triggerRenderSlot();
     });
@@ -635,11 +642,14 @@ function triggerInlineAddQuestion(dialogueId) {
   triggerInlineSaveDialogue(dialogueId);
 }
 
+// Même effet que triggerInlineUpdateBubbleText ci-dessous (mettre à jour
+// `.text` d'une ligne puis sauvegarder) — deux noms distincts car
+// référencés séparément dans le HTML généré (onchange de la question vs.
+// onchange de la bulle de réplique, voir triggerQuestionBubbleHtml/
+// triggerDialogueBubbleHtml), mais un seul corps (S4144 : déléguer plutôt
+// que dupliquer la logique).
 function triggerInlineUpdateQuestionText(dialogueId, index, text) {
-  const entry = _triggerDialogueRegistry[dialogueId];
-  if (!entry) return;
-  entry.dialogueRef.lines[index].text = text;
-  triggerInlineSaveDialogue(dialogueId);
+  triggerInlineUpdateBubbleText(dialogueId, index, text);
 }
 
 // Ajuste le NOMBRE de choix (2 à 4, voir db/dialogue_lines.py::
@@ -651,7 +661,7 @@ function triggerInlineSetQuestionChoiceCount(dialogueId, index, value) {
   const entry = _triggerDialogueRegistry[dialogueId];
   if (!entry) return;
   const line = entry.dialogueRef.lines[index];
-  const count = Math.max(2, Math.min(4, parseInt(value, 10) || 2));
+  const count = Math.max(2, Math.min(4, Number.parseInt(value, 10) || 2));
   while (line.choices.length < count) line.choices.push('');
   while (line.choices.length > count) line.choices.pop();
   if (line.correct_index >= line.choices.length) line.correct_index = 0;
@@ -676,7 +686,7 @@ function triggerInlineSetQuestionCorrectIndex(dialogueId, index, choiceIndex) {
 function triggerInlineSetQuestionRewardAmount(dialogueId, index, value) {
   const entry = _triggerDialogueRegistry[dialogueId];
   if (!entry) return;
-  entry.dialogueRef.lines[index].reward_amount = Math.max(0, parseInt(value, 10) || 0);
+  entry.dialogueRef.lines[index].reward_amount = Math.max(0, Number.parseInt(value, 10) || 0);
   triggerInlineSaveDialogue(dialogueId);
 }
 
@@ -755,7 +765,7 @@ function triggerRenderObjectStep() {
       if (!objects.length) { grid.innerHTML = '<p class="hint">Aucun objet éligible sur ce jeu.</p>'; return; }
       grid.innerHTML = objects.map((o, i) => `<button type="button" class="collisionWizardChoice questTriggerObjectChoice" style="animation-delay:${i * 40}ms" onclick="triggerSelectObject(${o.id})">`
           + `<div class="questTriggerObjectThumb">${collisionRuleThumbHtml(o)}</div>`
-          + `<span>${(o.name || '').replace(/</g, '&lt;')}</span>`
+          + `<span>${(o.name || '').replaceAll('<', '&lt;')}</span>`
         + '</button>').join('');
     });
 }
diff --git a/static/object_form.js b/static/object_form.js
index 5125678f..335f9f36 100644
--- a/static/object_form.js
+++ b/static/object_form.js
@@ -14,7 +14,12 @@
   var fieldsList = document.getElementById('fieldsList');
   var template = document.getElementById('fieldRowTemplate');
   var btnAddField = document.getElementById('btnAddField');
-  var NUMERIC_FIELD_TYPES = ['nombre_entier', 'nombre_decimal'];
+  var NUMERIC_FIELD_TYPES = new Set(['nombre_entier', 'nombre_decimal']);
+
+  function toggle(target, placeholder, visible) {
+    target.style.display = visible ? '' : 'none';
+    placeholder.style.display = visible ? 'none' : '';
+  }
 
   function wireRow(row) {
     // Ligne de TABLEAU dense (une ligne = un champ, comme "Champs
@@ -29,14 +34,9 @@
     var boundsTargets = row.querySelectorAll('.boundsTarget');
     var boundsPlaceholders = row.querySelectorAll('.boundsPlaceholder');
 
-    function toggle(target, placeholder, visible) {
-      target.style.display = visible ? '' : 'none';
-      placeholder.style.display = visible ? 'none' : '';
-    }
-
     function syncFieldTypeVisibility() {
       var isRelation = typeSelect.value === 'relation';
-      var isNumeric = NUMERIC_FIELD_TYPES.includes(typeSelect.value);
+      var isNumeric = NUMERIC_FIELD_TYPES.has(typeSelect.value);
       toggle(relationTarget, relationPlaceholder, isRelation);
       boundsTargets.forEach(function (el, i) { toggle(el, boundsPlaceholders[i], isNumeric); });
     }
-- 
2.54.0