Phase 3 : hardening qualite de code - typage strict, securite, dead code, a11y

Config strictement stricte partout (ruff, mypy --strict, bandit, vulture,
import-linter, eslint, stylelint), aucune regle desactivee "pour ne pas
casser le build" - l'existant a ete corrige pour la satisfaire plutot que
l'inverse. Hooks pre-commit locaux (language: system) bloquants.

- Typage mypy --strict propage a tout le moteur (db, screens, auth, core,
  ai, routes, puis publish/scripts/tests/app.py/build_css.py).
- Securite : fuite de handle fichier Windows corrigee dans l'export SCORM
  (routes/publish/export_scorm.py), CSRF/RNG non-crypto/xAPI documentes
  (# nosec, # NOSONAR justifies), nouveau db.json_for_script() (echappe
  "</script>" dans le JSON embarque en <script>, 25 sites).
- Architecture : imports circulaires/F811 nettoyes, contrats
  import-linter respectes, code mort retire (vulture).
- Accessibilite : 69 champs de formulaire sans label correctement
  associe corriges (for/id ou aria-label) sur 11 templates.
- ESLint/Stylelint : lot mecanique JS/CSS, regles ajustees puis
  appliquees (aucune desactivee sans verification individuelle).
- Tests : isolation du compte admin partage (nettoyage ponctuel +
  fixture de teardown automatique en filet de securite), suite complete
  verte (591 tests Python, 241 tests JS).
- SonarQube Community Build self-heberge (Docker + PostgreSQL) : rapport
  complet analyse point par point, faux positifs documentes.
- .gitattributes ajoute (LF force) : core.autocrlf=true sur cette machine
  faisait echouer ESLint (linebreak-style) via un bug connu de git
  (checkout "en place" qui ignore l'eol force sur un fichier deja
  present sur disque - contourne en supprimant puis recreant chaque
  fichier suivi).

djLint (H021, styles inline) volontairement saute pour ce commit -
backlog assume, deja documente, traite dans un lot separe.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

db/global_vars/coerce_structured_value.py

@@ -1,7 +1,7 @@
 import json
 
 
-def coerce_structured_value(var_type, value):
+def coerce_structured_value(var_type: str, value: str) -> str:
     """Pour une variable "objet"/"tableau" (voir db/constants.py), la
     valeur stockée doit rester du JSON analysable — sinon la prochaine
     lecture (_resolve_variable_path, screens/rendering/

db/global_vars/create_global_variable.py

@@ -1,9 +1,11 @@
 from ..connection import connect
-from .ensure_global_vars_schema import ensure_global_vars_schema, PLAYER_SHARED
 from .coerce_structured_value import coerce_structured_value
+from .ensure_global_vars_schema import PLAYER_SHARED, ensure_global_vars_schema
 
 
-def create_global_variable(slug, name, var_type="texte", default_value="", per_player=True):
+def create_global_variable(
+    slug: str, name: str, var_type: str = "texte", default_value: str = "", per_player: bool = True
+) -> int | None:
     """Crée la ligne "modèle" d'une variable globale (toujours
     player_id=PLAYER_SHARED, quel que soit per_player — voir
     ensure_global_vars_schema.py) si son nom n'existe pas déjà ; si elle
@@ -28,12 +30,12 @@ def create_global_variable(slug, name, var_type="texte", default_value="", per_p
     ).fetchone()
     if existing:
         conn.close()
-        return existing["id"]
+        return int(existing["id"])
     conn.execute(
         "INSERT INTO _global_variables (name, type, value, player_id, per_player) VALUES (?, ?, ?, ?, ?)",
         (name, var_type, default_value, PLAYER_SHARED, 1 if per_player else 0),
     )
-    new_id = conn.execute("SELECT last_insert_rowid() AS id").fetchone()["id"]
+    new_id = int(conn.execute("SELECT last_insert_rowid() AS id").fetchone()["id"])
     conn.commit()
     conn.close()
     return new_id

db/global_vars/delete_global_variable.py

@@ -2,7 +2,7 @@ from ..connection import connect
 from .ensure_global_vars_schema import ensure_global_vars_schema
 
 
-def delete_global_variable(slug, name):
+def delete_global_variable(slug: str, name: str) -> None:
     """Supprime TOUTES les lignes de ce nom, pas seulement la ligne modèle
     PLAYER_SHARED — une variable per_player peut avoir une ligne par joueur
     ayant déjà écrit dessus (voir update_global_variable_value.py)."""

db/global_vars/delete_global_variable_by_id.py

@@ -2,7 +2,7 @@ from ..connection import connect
 from .ensure_global_vars_schema import ensure_global_vars_schema
 
 
-def delete_global_variable_by_id(slug, var_id):
+def delete_global_variable_by_id(slug: str, var_id: int) -> None:
     """Version par id de delete_global_variable — utilisée par la page de
     gestion des variables (game_variables.html), où chaque ligne connaît son
     id technique mais pas nécessairement un nom encore garanti unique côté

db/global_vars/ensure_global_vars_schema.py

@@ -3,7 +3,7 @@ from ..connection import connect
 PLAYER_SHARED = "__shared__"
 
 
-def ensure_global_vars_schema(slug):
+def ensure_global_vars_schema(slug: str) -> None:
     """Migration légère (même principe que ensure_field_bounds_schema.py) :
     crée _global_variables si absente. Depuis l'état par joueur (Phase 1),
     une variable a une ligne "modèle" créée par le créateur du jeu

db/global_vars/get_global_variable.py

@@ -1,9 +1,11 @@
+from typing import Any
+
 from ..connection import connect
-from .ensure_global_vars_schema import ensure_global_vars_schema, PLAYER_SHARED
+from .ensure_global_vars_schema import PLAYER_SHARED, ensure_global_vars_schema
 from .resolve_player_key import resolve_player_key
 
 
-def get_global_variable(slug, name, player_id=PLAYER_SHARED):
+def get_global_variable(slug: str, name: str, player_id: str = PLAYER_SHARED) -> dict[str, Any] | None:
     """Par NOM (pas par id — c'est comme ça qu'une variable est référencée
     partout ailleurs, condition de visibilité, action "Modifier une
     variable") et par joueur (voir resolve_player_key.py) : une variable

db/global_vars/list_global_variables.py

@@ -1,8 +1,10 @@
+from typing import Any
+
 from ..connection import connect
-from .ensure_global_vars_schema import ensure_global_vars_schema, PLAYER_SHARED
+from .ensure_global_vars_schema import PLAYER_SHARED, ensure_global_vars_schema
 
 
-def list_global_variables(slug):
+def list_global_variables(slug: str) -> list[dict[str, Any]]:
     """Toujours les lignes MODÈLES (PLAYER_SHARED) — c'est la liste des
     variables telle que le créateur les a définies dans le tableau de
     bord, jamais influencée par le nombre de joueurs ayant déjà leur

db/global_vars/list_global_variables_for_player.py

@@ -1,9 +1,11 @@
+from typing import Any
+
 from .ensure_global_vars_schema import PLAYER_SHARED
-from .list_global_variables import list_global_variables
 from .get_global_variable import get_global_variable
+from .list_global_variables import list_global_variables
 
 
-def list_global_variables_for_player(slug, player_id=PLAYER_SHARED):
+def list_global_variables_for_player(slug: str, player_id: str = PLAYER_SHARED) -> list[dict[str, Any]]:
     """Valeur EFFECTIVE de chaque variable pour ce joueur (voir
     get_global_variable.py : la ligne propre à ce joueur si elle existe
     déjà, sinon la valeur par défaut de la ligne modèle) — à la différence
@@ -11,7 +13,7 @@ def list_global_variables_for_player(slug, player_id=PLAYER_SHARED):
     tableau de bord), c'est cette version qu'il faut exposer au runtime
     jouable (full_game_payload.py), pour qu'une condition évaluée côté
     client reflète bien l'état RÉEL de CE joueur."""
-    result = []
+    result: list[dict[str, Any]] = []
     for template in list_global_variables(slug):
         value = get_global_variable(slug, template["name"], player_id)
         result.append(value if value else template)

db/global_vars/resolve_player_key.py

@@ -1,7 +1,9 @@
+import sqlite3
+
 from .ensure_global_vars_schema import PLAYER_SHARED
 
 
-def resolve_player_key(conn, name, player_id):
+def resolve_player_key(conn: sqlite3.Connection, name: str, player_id: str) -> str:
     """Détermine le player_id à utiliser RÉELLEMENT pour lire/écrire cette
     variable : celui du joueur (variable per_player=1, le cas par défaut),
     ou toujours PLAYER_SHARED (variable explicitement partagée entre tous

db/global_vars/update_global_variable.py

@@ -1,9 +1,11 @@
+from typing import Any
+
 from ..connection import connect
-from .ensure_global_vars_schema import ensure_global_vars_schema
 from .coerce_structured_value import coerce_structured_value
+from .ensure_global_vars_schema import ensure_global_vars_schema
 
 
-def update_global_variable(slug, var_id, var_type, value):
+def update_global_variable(slug: str, var_id: int, var_type: str, value: Any) -> None:
     """Modifie le type et la valeur d'une variable existante depuis le
     tableau de bord (onglet Variables, game_dashboard.html) — le NOM reste
     volontairement immuable après création : c'est par ce nom qu'une

db/global_vars/update_global_variable_value.py

@@ -1,9 +1,11 @@
+from typing import Any
+
 from ..connection import connect
-from .ensure_global_vars_schema import ensure_global_vars_schema, PLAYER_SHARED
+from .ensure_global_vars_schema import PLAYER_SHARED, ensure_global_vars_schema
 from .resolve_player_key import resolve_player_key
 
 
-def update_global_variable_value(slug, name, new_value, player_id=PLAYER_SHARED):
+def update_global_variable_value(slug: str, name: str, new_value: Any, player_id: str = PLAYER_SHARED) -> bool:
     """Écrit une nouvelle valeur BRUTE (déjà calculée par l'appelant) sur la
     variable — utilisé aussi bien par l'action "Modifier une variable" (voir
     screens/data_actions/apply_variable_action.py) que par une éventuelle
@@ -17,9 +19,7 @@ def update_global_variable_value(slug, name, new_value, player_id=PLAYER_SHARED)
     ensure_global_vars_schema(slug)
     conn = connect(slug)
     key = resolve_player_key(conn, name, player_id)
-    existing = conn.execute(
-        "SELECT id FROM _global_variables WHERE name = ? AND player_id = ?", (name, key)
-    ).fetchone()
+    existing = conn.execute("SELECT id FROM _global_variables WHERE name = ? AND player_id = ?", (name, key)).fetchone()
     if existing:
         conn.execute("UPDATE _global_variables SET value = ? WHERE id = ?", (str(new_value), existing["id"]))
     else: