Implemente un systeme de pages pour le support de formation

Retour utilisateur : "il faut implementer un systeme de page". Un
support est desormais compose de PLUSIEURS pages (_document_pages),
chacune un document independant affiche seul sur le canevas -- chaque
element appartient a exactement une page via page_id (document_engine/
elements/*, routes/document/document_element_add.py/document_render.py
revalident desormais un page_id explicite). Migration automatique et
silencieuse pour les supports crees avant cette fonctionnalite
(db/supports/ensure_document_pages_schema.py, meme convention que les
ensure_X_schema.py existants) : leurs elements deviennent tous les
enfants d'une "Page 1" creee a la volee, aucune perte de contenu.

Nouveau paquet document_engine/pages/ (add/list/get/rename/move/delete)
et 4 routes dediees (routes/document/document_page_*.py) -- supprimer
la DERNIERE page restante est refuse (garde-fou pose a la route, meme
decoupage que routes/game/screens/screen_delete.py cote jeu, jamais
dans la fonction bas niveau).

Cote editeur : une bande d'ONGLETS au-dessus du canevas (jamais un
panneau lateral, choix explicite de l'utilisateur) -- clic pour changer
de page, double-clic pour renommer (contenteditable), glisser pour
reordonner, "+" pour ajouter, "x" pour supprimer. Changer de page vide
la pile Annuler/Retablir (une commande empilee sur une autre page n'a
plus de sens). Mode Apercu : navigation Page precedente/suivante avec
indicateur "Page X / N" (choix explicite : page par page, pas de
defilement continu), jamais affichee s'il n'y a qu'une seule page.

Verifie : suite pytest complete (702 tests, dont 14 nouveaux pour les
routes de pages), simulation DOM reelle (jsdom, 25 assertions couvrant
tout le cycle de vie cote client -- creation/bascule/renommage/
reordonnancement/suppression de page, portee correcte des elements par
page, pile Annuler/Retablir videe au changement de page, pilule de
navigation en Apercu), et un test de fumee HTTP reel contre le serveur
de dev en marche (creation/ajout d'element/rendu/renommage/suppression
d'une page, refus de supprimer la derniere page, page inconnue -> 404).

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

routes/document/__init__.py

@@ -11,5 +11,9 @@ from . import (  # noqa: F401 - enregistre les routes definies dans chaque modul
     document_element_move,
     document_element_update,
     document_new,
+    document_page_add,
+    document_page_delete,
+    document_page_move,
+    document_page_rename,
     document_render,
 )

routes/document/document_edit.py

@@ -13,6 +13,14 @@ def document_edit(slug: str) -> str:
     ses écrans -> éditeur de scène) : ici la carte "Mes formations" mène
     directement ici.
 
+    Un support est composé de plusieurs PAGES (voir document_engine/
+    pages/, retour utilisateur du 21/09/2026 : "il faut implémenter un
+    système de page") : le canevas n'affiche au chargement que la
+    PREMIÈRE page (triée par order_index) — changer de page se fait
+    ensuite entièrement côté client via /document/<slug>/render?page_id=
+    (voir static/document/js/document-editor.js), jamais un rechargement
+    complet de cette route.
+
     Les attributs de chaque élément sont revalidés (document_engine.
     sanitize_element_attributes) avant d'atteindre le client — jamais les
     valeurs brutes stockées telles quelles : un élément dont le schéma a
@@ -21,13 +29,17 @@ def document_edit(slug: str) -> str:
     panneau Propriétés côté client, qui suppose la forme ACTUELLE (bug réel
     constaté le 21/09/2026)."""
     support = db.support_meta(slug)
+    pages = document_engine.list_document_pages(slug)
+    active_page = pages[0]
     elements = [
         {**el, "attributes": document_engine.sanitize_element_attributes(el["kind"], el["attributes"])}
-        for el in document_engine.list_document_elements(slug)
+        for el in document_engine.list_document_elements(slug, active_page["id"])
     ]
     return render_template(
         "document/document_edit.html",
         support=support,
+        pages=pages,
+        active_page=active_page,
         elements=elements,
         rendered_document=document_engine.render_document(elements),
         element_library=document_engine.ELEMENT_LIBRARY,

routes/document/document_element_add.py

@@ -10,25 +10,29 @@ from core.flask_app import app
 
 @app.route("/document/<slug>/elements/add", methods=["POST"])
 def document_element_add(slug: str) -> Response | tuple[Response, int]:
-    """Ajoute un élément — appelée en AJAX depuis la bibliothèque du
-    panneau gauche (clic ou glisser-déposer initial), OU par le moteur de
-    layout lui-même pour créer une rangée à la volée au moment d'un dépôt
-    latéral (kind="row" — jamais choisi directement dans la bibliothèque,
-    absent de document_engine.ELEMENT_LIBRARY, mais un kind valide comme
-    un autre pour cette route ; voir static/document/js/document-editor.js).
-    parent_id, quand fourni, place l'élément directement dans une rangée
-    existante."""
+    """Ajoute un élément à une page précise — appelée en AJAX depuis la
+    bibliothèque du panneau gauche (clic ou glisser-déposer initial), OU
+    par le moteur de layout lui-même pour créer une rangée à la volée au
+    moment d'un dépôt latéral (kind="row" — jamais choisi directement
+    dans la bibliothèque, absent de document_engine.ELEMENT_LIBRARY, mais
+    un kind valide comme un autre pour cette route ; voir
+    static/document/js/document-editor.js). parent_id, quand fourni,
+    place l'élément directement dans une rangée existante DE CETTE MÊME
+    PAGE."""
     kind = request.form.get("kind", "")
     if kind not in document_engine.ELEMENT_KIND_LABELS:
         return jsonify({"error": "type d'élément inconnu"}), 400
+    page_id = request.form.get("page_id", type=int)
+    if page_id is None or document_engine.get_document_page(slug, page_id) is None:
+        return jsonify({"error": "page introuvable"}), 404
     parent_id = request.form.get("parent_id", type=int)
-    element_id = document_engine.add_document_element(slug, kind, parent_id=parent_id)
+    element_id = document_engine.add_document_element(slug, kind, page_id=page_id, parent_id=parent_id)
     element = db.assert_not_none(
         document_engine.get_document_element(slug, element_id),
         "element_id vient d'etre cree par add_document_element juste au-dessus",
     )
     elements_by_parent: dict[int | None, list[dict[str, Any]]] = {}
-    for el in document_engine.list_document_elements(slug):
+    for el in document_engine.list_document_elements(slug, page_id):
         elements_by_parent.setdefault(el["parent_id"], []).append(el)
     return jsonify(
         {

routes/document/document_element_update.py

@@ -37,7 +37,7 @@ def document_element_update(slug: str, element_id: int) -> Response | tuple[Resp
         "element_id verifie present juste au-dessus, aucune suppression concurrente possible entre-temps ici",
     )
     elements_by_parent: dict[int | None, list[dict[str, Any]]] = {}
-    for el in document_engine.list_document_elements(slug):
+    for el in document_engine.list_document_elements(slug, element["page_id"]):
         elements_by_parent.setdefault(el["parent_id"], []).append(el)
     return jsonify(
         {

routes/document/document_page_add.py

@@ -0,0 +1,19 @@
+from flask import jsonify, request
+from werkzeug.wrappers import Response
+
+import document_engine
+from core.flask_app import app
+
+
+@app.route("/document/<slug>/pages/add", methods=["POST"])
+def document_page_add(slug: str) -> Response:
+    """Ajoute une page en fin de la bande d'onglets — appelée en AJAX
+    depuis le "+" de static/document/js/document-editor.js. Le client
+    bascule ensuite lui-même la page active sur cette nouvelle page (via
+    /document/<slug>/render?page_id=<id>), jamais un rendu HTML renvoyé
+    ici : une page neuve n'a aucun élément à rendre."""
+    payload = request.get_json(silent=True) or {}
+    title = payload.get("title")
+    page_id = document_engine.add_document_page(slug, title=title)
+    page = document_engine.get_document_page(slug, page_id)
+    return jsonify({"id": page_id, "title": page["title"] if page else title})

routes/document/document_page_delete.py

@@ -0,0 +1,20 @@
+from flask import jsonify
+from werkzeug.wrappers import Response
+
+import document_engine
+from core.flask_app import app
+
+
+@app.route("/document/<slug>/pages/<int:page_id>/delete", methods=["POST"])
+def document_page_delete(slug: str, page_id: int) -> Response | tuple[Response, int]:
+    """Supprime une page — refuse de supprimer la DERNIÈRE page restante
+    (un support a toujours au moins une page, voir document_engine/pages/
+    pages.md) : le garde-fou vit ici, à la route, pas dans
+    delete_document_page (même découpage que routes/game/screens/
+    screen_delete.py côté jeu, qui bloque aussi au niveau route)."""
+    if document_engine.get_document_page(slug, page_id) is None:
+        return jsonify({"error": "page introuvable"}), 404
+    if len(document_engine.list_document_pages(slug)) <= 1:
+        return jsonify({"error": "impossible de supprimer la dernière page"}), 400
+    document_engine.delete_document_page(slug, page_id)
+    return jsonify({"ok": True})

routes/document/document_page_move.py

@@ -0,0 +1,18 @@
+from flask import jsonify, request
+from werkzeug.wrappers import Response
+
+import document_engine
+from core.flask_app import app
+
+
+@app.route("/document/<slug>/pages/<int:page_id>/move", methods=["POST"])
+def document_page_move(slug: str, page_id: int) -> Response | tuple[Response, int]:
+    """Réordonne une page dans la bande d'onglets — new_index calculé
+    côté client (glisser-déposer d'un onglet, voir static/document/js/
+    document-editor.js)."""
+    if document_engine.get_document_page(slug, page_id) is None:
+        return jsonify({"error": "page introuvable"}), 404
+    payload = request.get_json(force=True) or {}
+    new_index = int(payload.get("new_index", 0))
+    document_engine.move_document_page(slug, page_id, new_index)
+    return jsonify({"ok": True})

routes/document/document_page_rename.py

@@ -0,0 +1,20 @@
+from flask import jsonify, request
+from werkzeug.wrappers import Response
+
+import document_engine
+from core.flask_app import app
+
+
+@app.route("/document/<slug>/pages/<int:page_id>/rename", methods=["POST"])
+def document_page_rename(slug: str, page_id: int) -> Response | tuple[Response, int]:
+    """Renomme une page — renvoie le titre RÉELLEMENT persisté (jamais
+    celui envoyé tel quel) : update_document_page ignore silencieusement
+    un titre vide, le client doit refléter ce que le serveur a vraiment
+    gardé, même convention que document_element_update.py."""
+    if document_engine.get_document_page(slug, page_id) is None:
+        return jsonify({"error": "page introuvable"}), 404
+    payload = request.get_json(force=True) or {}
+    document_engine.update_document_page(slug, page_id, str(payload.get("title", "")))
+    page = document_engine.get_document_page(slug, page_id)
+    title = page["title"] if page else ""
+    return jsonify({"ok": True, "title": title})

routes/document/document_render.py

@@ -1,4 +1,4 @@
-from flask import jsonify
+from flask import jsonify, request
 from werkzeug.wrappers import Response
 
 import document_engine
@@ -6,19 +6,24 @@ from core.flask_app import app
 
 
 @app.route("/document/<slug>/render")
-def document_render(slug: str) -> Response:
-    """Rendu HTML complet et à jour du document — appelé par le moteur de
-    layout côté client après toute mutation structurelle (ajout/déplacement/
-    suppression) pour reconstruire le canevas depuis la vérité serveur
-    (recalcul réel des rangées, jamais une simple retouche DOM locale, voir
-    docs/plan/PLAN.md — "recalcul au déplacement").
+def document_render(slug: str) -> Response | tuple[Response, int]:
+    """Rendu HTML complet et à jour d'UNE PAGE du document (?page_id=) —
+    appelé par le moteur de layout côté client après toute mutation
+    structurelle (ajout/déplacement/suppression) pour reconstruire le
+    canevas depuis la vérité serveur (recalcul réel des rangées, jamais
+    une simple retouche DOM locale, voir docs/plan/PLAN.md — "recalcul au
+    déplacement"). Le canevas n'affiche jamais qu'une seule page à la
+    fois (voir document_engine/pages/), d'où ce paramètre.
 
     `elements` est revalidé (document_engine.sanitize_element_attributes)
     avant d'être renvoyé au client — même raison que routes/document/
     document_edit.py : le panneau Propriétés reçoit `data.elements`
     directement depuis cette route à chaque rafraîchissement du canevas."""
+    page_id = request.args.get("page_id", type=int)
+    if page_id is None or document_engine.get_document_page(slug, page_id) is None:
+        return jsonify({"error": "page introuvable"}), 404
     elements = [
         {**el, "attributes": document_engine.sanitize_element_attributes(el["kind"], el["attributes"])}
-        for el in document_engine.list_document_elements(slug)
+        for el in document_engine.list_document_elements(slug, page_id)
     ]
     return jsonify({"html": document_engine.render_document(elements), "elements": elements})