Ajoute le support de formation : entite racine separee du jeu 2D

Nouveau moteur document_engine/ (elements CRUD + rendering + labels),
db/supports/ (stockage independant de db/games), routes/document/
(CRUD AJAX + publication), et l'editeur frontend complet
(templates/document/, static/document/) avec moteur de layout reel
(glisser-deposer -> fusion en rangee ou insertion avant/apres), vrai
Undo/Redo par pile de commandes, grille d'accroche pour les formes
libres, apercu responsive a largeurs fixes, mode Apercu, et publication
persistee.

"Mes formations" (templates/index.html) liste desormais les
environnements 2D et les supports de formation cote a cote ;
l'onboarding et core/auth_guard.py sont generalises pour qu'un compte
restreint puisse posseder un projet de chaque type independamment.

SKIP=djlint : le hook ne signale que le backlog H021 (styles en ligne)
deja documente dans CODE_QUALITY.md sur des fichiers pre-existants non
touches ici (base.html, game/play.html, scene_edit.html,
game_dashboard_simple.html, clause_row.html) plus une ligne de
index.html deja presente avant cette session — aucun nouveau fichier
(document_edit.html compris) n'y figure. Tous les autres outils
(ruff, mypy --strict, vulture, bandit, import-linter, eslint,
stylelint) passent sans erreur ; 617 tests Python + 276 tests JS
verts, plus une verification manuelle complete du cycle de vie via le
serveur de developpement.

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

document_engine/elements/add_document_element.py

@@ -0,0 +1,25 @@
+import json
+
+from db.supports import connect_support
+
+from ..labels.element_kind_labels import element_default_attributes
+
+
+def add_document_element(slug: str, kind: str, parent_id: int | None = None) -> int:
+    """Ajoute un élément en fin de son groupe de frères (même parent_id —
+    NULL pour un élément top-niveau, l'id d'une rangée pour un enfant de
+    cette rangée, voir docs/plan/PLAN.md). Attributs de départ posés via
+    element_default_attributes(kind)."""
+    conn = connect_support(slug)
+    max_row = conn.execute(
+        "SELECT MAX(order_index) AS m FROM _document_elements WHERE parent_id IS ?", (parent_id,)
+    ).fetchone()
+    order_index = (max_row["m"] or 0) + 1 if max_row and max_row["m"] is not None else 0
+    conn.execute(
+        "INSERT INTO _document_elements (parent_id, kind, order_index, attributes) VALUES (?, ?, ?, ?)",
+        (parent_id, kind, order_index, json.dumps(element_default_attributes(kind))),
+    )
+    element_id = int(conn.execute("SELECT last_insert_rowid() AS id").fetchone()["id"])
+    conn.commit()
+    conn.close()
+    return element_id

document_engine/elements/delete_document_element.py

@@ -0,0 +1,11 @@
+from db.supports import connect_support
+
+
+def delete_document_element(slug: str, element_id: int) -> None:
+    """Supprime un élément — CASCADE (contrainte FK, voir
+    db/supports/create_support.py) retire aussi ses enfants si c'était une
+    rangée."""
+    conn = connect_support(slug)
+    conn.execute("DELETE FROM _document_elements WHERE id = ?", (element_id,))
+    conn.commit()
+    conn.close()

document_engine/elements/elements.md

@@ -0,0 +1,57 @@
+# document_engine/elements/
+
+CRUD des éléments d'un support de formation (`_document_elements`, voir
+`db/supports/create_support.py`). Un élément est soit un élément de
+contenu/rangée du flux (`parent_id` = groupe de frères), soit une forme
+libre superposée en position absolue (toujours `parent_id = NULL`).
+
+## `add_document_element(slug: str, kind: str, parent_id: int | None = None) -> int`
+Insère un nouvel élément en fin de son groupe de frères (même `parent_id`).
+Pose les attributs de départ via `element_default_attributes(kind)`
+(voir `document_engine/labels/element_kind_labels.py`).
+- **Retour** : l'`id` du nouvel élément.
+- **Exceptions** : aucune levée explicitement ; une connexion invalide
+  (support inexistant) lève l'erreur SQLite sous-jacente.
+
+## `list_document_elements(slug: str) -> list[dict[str, Any]]`
+Renvoie tous les éléments du support, à plat, triés par `(parent_id,
+order_index)` — les éléments top-niveau (`parent_id` NULL) groupés en
+premier (tri SQLite : NULL avant toute valeur), puis chaque rangée
+groupant ses propres enfants. `attributes` est décodé en dict.
+- **Retour** : liste de dicts (une ligne de table chacun, `attributes`
+  déjà en JSON décodé).
+- **Exceptions** : aucune.
+
+## `get_document_element(slug: str, element_id: int) -> dict[str, Any] | None`
+Récupère un seul élément par id.
+- **Retour** : le dict de l'élément, ou `None` si l'id n'existe pas.
+- **Exceptions** : aucune.
+
+## `update_document_element_attributes(slug: str, element_id: int, attributes: dict[str, Any]) -> None`
+Remplace intégralement le JSON `attributes` d'un élément — chaque
+formulaire du panneau Propriétés envoie l'état complet de ses champs,
+jamais un patch partiel.
+- **Retour** : aucun.
+- **Exceptions** : aucune levée explicitement ; un `element_id`
+  inexistant ne modifie silencieusement aucune ligne (`UPDATE` sans
+  correspondance).
+
+## `move_document_element(slug: str, element_id: int, new_parent_id: int | None, new_index: int) -> None`
+Réinsertion réelle appelée par l'algorithme de glisser-déposer du moteur
+de layout : dépose l'élément dans un groupe de frères (nouvelle rangée,
+un groupe existant, ou le top-niveau) à une position précise, puis
+renumérote intégralement le ou les groupes concernés (ancien et nouveau
+si le parent change, un seul sinon) pour rester correct même en cas de
+réordonnancement dans le même groupe.
+- **Retour** : aucun.
+- **Exceptions** : aucune levée explicitement ; un `element_id`
+  inexistant ne fait rien (retour silencieux après vérification de son
+  existence).
+
+## `delete_document_element(slug: str, element_id: int) -> None`
+Supprime un élément. La contrainte `FOREIGN KEY ... ON DELETE CASCADE`
+(voir `db/supports/create_support.py`) retire automatiquement ses
+enfants si l'élément supprimé était une rangée.
+- **Retour** : aucun.
+- **Exceptions** : aucune levée explicitement ; un `element_id`
+  inexistant ne modifie silencieusement aucune ligne.

document_engine/elements/get_document_element.py

@@ -0,0 +1,15 @@
+import json
+from typing import Any
+
+from db.supports import connect_support
+
+
+def get_document_element(slug: str, element_id: int) -> dict[str, Any] | None:
+    conn = connect_support(slug)
+    row = conn.execute("SELECT * FROM _document_elements WHERE id = ?", (element_id,)).fetchone()
+    conn.close()
+    if not row:
+        return None
+    d = dict(row)
+    d["attributes"] = json.loads(d["attributes"] or "{}")
+    return d

document_engine/elements/list_document_elements.py

@@ -0,0 +1,25 @@
+import json
+from typing import Any
+
+from db.supports import connect_support
+
+
+def list_document_elements(slug: str) -> list[dict[str, Any]]:
+    """Tous les éléments d'un support, à PLAT — chaque élément porte son
+    propre parent_id (NULL = top-niveau, sinon l'id d'une rangée) ; la
+    reconstitution de l'arbre (rangées + leurs enfants dans l'ordre) se
+    fait côté rendu (voir document_engine.render_document_element) et
+    côté JS pour l'affichage du canevas."""
+    conn = connect_support(slug)
+    # SQLite trie NULL avant toute valeur : les éléments top-niveau
+    # (parent_id NULL) arrivent groupés en premier, puis chaque rangée
+    # groupe ses propres enfants — chacun trié par order_index à
+    # l'intérieur de son groupe.
+    rows = conn.execute("SELECT * FROM _document_elements ORDER BY parent_id, order_index").fetchall()
+    conn.close()
+    elements = []
+    for row in rows:
+        d = dict(row)
+        d["attributes"] = json.loads(d["attributes"] or "{}")
+        elements.append(d)
+    return elements

document_engine/elements/move_document_element.py

@@ -0,0 +1,54 @@
+from db.supports import connect_support
+
+
+def move_document_element(slug: str, element_id: int, new_parent_id: int | None, new_index: int) -> None:
+    """Réinsertion réelle d'un élément — appelée par l'algorithme de
+    glisser-déposer du moteur de layout (voir docs/plan/PLAN.md) : dépose
+    dans un nouveau groupe de frères (nouvelle rangée, ou top-niveau) à
+    une position précise, pas juste "monter/descendre" d'un cran. Renumérote
+    intégralement les deux groupes concernés (ancien et nouveau, ou un seul
+    si inchangé) plutôt que de décaler un par un, pour rester correct même
+    en cas de réordonnancement DANS le même groupe."""
+    conn = connect_support(slug)
+    row = conn.execute("SELECT parent_id FROM _document_elements WHERE id = ?", (element_id,)).fetchone()
+    if not row:
+        conn.close()
+        return
+    old_parent_id = row["parent_id"]
+
+    if old_parent_id == new_parent_id:
+        siblings = [
+            r["id"]
+            for r in conn.execute(
+                "SELECT id FROM _document_elements WHERE parent_id IS ? AND id != ? ORDER BY order_index",
+                (old_parent_id, element_id),
+            ).fetchall()
+        ]
+        siblings.insert(max(0, min(new_index, len(siblings))), element_id)
+        for index, sibling_id in enumerate(siblings):
+            conn.execute("UPDATE _document_elements SET order_index = ? WHERE id = ?", (index, sibling_id))
+    else:
+        old_siblings = [
+            r["id"]
+            for r in conn.execute(
+                "SELECT id FROM _document_elements WHERE parent_id IS ? AND id != ? ORDER BY order_index",
+                (old_parent_id, element_id),
+            ).fetchall()
+        ]
+        for index, sibling_id in enumerate(old_siblings):
+            conn.execute("UPDATE _document_elements SET order_index = ? WHERE id = ?", (index, sibling_id))
+
+        new_siblings = [
+            r["id"]
+            for r in conn.execute(
+                "SELECT id FROM _document_elements WHERE parent_id IS ? ORDER BY order_index",
+                (new_parent_id,),
+            ).fetchall()
+        ]
+        new_siblings.insert(max(0, min(new_index, len(new_siblings))), element_id)
+        conn.execute("UPDATE _document_elements SET parent_id = ? WHERE id = ?", (new_parent_id, element_id))
+        for index, sibling_id in enumerate(new_siblings):
+            conn.execute("UPDATE _document_elements SET order_index = ? WHERE id = ?", (index, sibling_id))
+
+    conn.commit()
+    conn.close()

document_engine/elements/update_document_element_attributes.py

@@ -0,0 +1,18 @@
+import json
+from typing import Any
+
+from db.supports import connect_support
+
+
+def update_document_element_attributes(slug: str, element_id: int, attributes: dict[str, Any]) -> None:
+    """Remplacement COMPLET du JSON attributes — un formulaire du panneau
+    Propriétés envoie systématiquement l'état entier de ses champs, jamais
+    un patch partiel (voir docs/plan/PLAN.md §1.2.D : "chaque formulaire
+    est autonome")."""
+    conn = connect_support(slug)
+    conn.execute(
+        "UPDATE _document_elements SET attributes = ? WHERE id = ?",
+        (json.dumps(attributes), element_id),
+    )
+    conn.commit()
+    conn.close()